Explicit type conversion

Convertit entre les types en utilisant une combinaison de conversions explicites et implicites.

Syntaxe

Convertit explicitement n'importe quel nombre de valeurs en une valeur du type cible.

Explication

Résolution d'Ambiguïté

Instruction de déclaration ambiguë

En cas d'ambiguïté entre une instruction d'expression avec une expression de conversion de style fonction comme sous-expression la plus à gauche et une instruction de déclaration, l'ambiguïté est résolue en la traitant comme une déclaration. Cette désambiguïsation est purement syntaxique : elle ne prend pas en compte la signification des noms apparaissant dans l'instruction, sauf pour déterminer s'ils sont des noms de type :

struct M {};
struct L { L(M&); };
M n;
void f()
{
    M(m);    // déclaration, équivalent à M m;
    L(n);    // déclaration mal formée, équivalent à L n;
    L(l)(m); // toujours une déclaration, équivalent à L l((m));
}

struct M;
struct S
{
    S* operator()();
    int N;
    int M;
    void mem(S s)
    {
        auto(s)()->M; // expression (S::M cache ::M), invalide avant C++23
    }
};
void f(S s)
{
    {
        auto(s)()->N; // expression, invalide avant C++23
        auto(s)()->M; // déclaration de fonction, équivalent à M s();
    }
    {
        S(s)()->N;    // expression
        S(s)()->M;    // expression
    }
}

Paramètre de fonction ambigu

L'ambiguïté ci-dessus peut également se produire dans le contexte d'une déclaration. Dans ce contexte, le choix se situe entre une déclaration d'objet avec un cast de style fonction comme initialiseur et une déclaration impliquant un déclarateur de fonction avec un ensemble redondant de parenthèses autour d'un nom de paramètre. La résolution consiste également à considérer toute construction, telle que la déclaration de paramètre potentielle, qui pourrait possiblement être une déclaration comme étant une déclaration :

struct S
{
    S(int);
};
void foo(double a)
{
    S w(int(a)); // déclaration de fonction : possède un paramètre `a` de type int
    S x(int());  // déclaration de fonction : possède un paramètre sans nom de type int(*)() 
                 // qui est ajusté à partir de int()
    // Méthodes pour éviter l'ambiguïté :
    S y((int(a))); // déclaration d'objet : parenthèses supplémentaires
    S y((int)a);   // déclaration d'objet : cast de style C
    S z = int(a);  // déclaration d'objet : aucune ambiguïté pour cette syntaxe
}

typedef struct BB { int C[2]; } *B, C;
void foo()
{
    S a(B()->C);    // déclaration d'objet : B()->C ne peut pas déclarer un paramètre
    S b(auto()->C); // déclaration de fonction : possède un paramètre sans nom de type C(*)()
                    // qui est ajusté à partir de C()
}

Identifiant de type ambigu

Une ambiguïté peut survenir de la similarité entre un cast de style fonction et un type-id . La résolution est que toute construction qui pourrait possiblement être un type-id dans son contexte syntaxique doit être considérée comme un type-id :

// `int()` et `int(unsigned(a))` peuvent tous deux être analysés comme type-id :
// `int()`            représente une fonction retournant int
//                    et ne prenant aucun argument
// `int(unsigned(a))` représente une fonction retournant int
//                    et prenant un argument de type unsigned
void foo(signed char a)
{
    sizeof(int());            // type-id (incorrect)
    sizeof(int(a));           // expression
    sizeof(int(unsigned(a))); // type-id (incorrect)
    (int()) + 1;            // type-id (incorrect)
    (int(a)) + 1;           // expression
    (int(unsigned(a))) + 1; // type-id (incorrect)
}

typedef struct BB { int C[2]; } *B, C;
void foo()
{
    sizeof(B()->C[1]);    // OK, sizeof(expression)
    sizeof(auto()->C[1]); // error: sizeof of a function returning an array
}

Notes

Exemple

#include <cassert>
#include <iostream>
double f = 3.14;
unsigned int n1 = (unsigned int)f; // C-style cast
unsigned int n2 = unsigned(f);     // function-style cast
class C1;
class C2;
C2* foo(C1* p)
{
    return (C2*)p; // casts incomplete type to incomplete type
}
void cpp23_decay_copy_demo()
{
    auto inc_print = [](int& x, const int& y)
    {
        ++x;
        std::cout << "x:" << x << ", y:" << y << '\n';
    };
    int p{1};
    inc_print(p, p); // prints x:2 y:2, because param y here is an alias of p
    int q{1};
    inc_print(q, auto{q}); // prints x:2 y:1, auto{q} (C++23) casts to prvalue,
                           // so the param y is a copy of q (not an alias of q)
}
// In this example, C-style cast is interpreted as static_cast
// even though it would work as reinterpret_cast
struct A {};
struct I1 : A {};
struct I2 : A {};
struct D : I1, I2 {};
int main()
{
    D* d = nullptr;
//  A* a = (A*)d;                   // compile-time error
    A* a = reinterpret_cast<A*>(d); // this compiles
    assert(a == nullptr);
    cpp23_decay_copy_demo();
}

x:2 y:2
x:2 y:1

Rapports de défauts

Les rapports de défauts modifiant le comportement suivants ont été appliqués rétroactivement aux normes C++ précédemment publiées.

Références

Voir aussi