Voir la source de cpp/language/explicit cast

Vous n’avez pas le droit de modifier cette page, pour la raison suivante :
L’action que vous essayez de réaliser n’est permise qu’aux utilisateurs d’un des groupes : Utilisateurs, Administrateurs.
Vous pouvez voir et copier le contenu de cette page.
{{tr_note}}
{{title|explicit type conversion}}
{{cpp/language/navbar}}
{{tr|Convertit entre les types en utilisant une combinaison de conversions implicites et explicites .|Converts between types using a combination of explicit and implicit conversions.}}

===Syntaxe===
{{sdsc begin}}
{{sdsc | {{ttb|(}} {{spar|new_type}} {{ttb|) }} {{spar|expression}} | num=1 }} 
{{sdsc | {{spar|new_type}} {{ttb|( }} {{spar|expression}} {{ttb|)}}  | num=2 }} 
{{sdsc end}}

{{tr|Renvoie une valeur de type .. {{tt|new_type}}|Returns a value of type {{tt|new_type}}.}}

===Explication===
@1@ {{tr|Lorsque l'expression de cast de style C est rencontrée, le compilateur tente les expressions de transtypage suivantes, dans cet ordre:|When the C-style cast expression is encountered, the compiler attempts the following cast expressions, in this order:}}
:@a@ {{c|const_cast<new_type>(expression)}}
:@b@ {{tr|{{c|static_cast<new_type>(expression)}}, avec des extensions: pointeur ou une référence à une classe dérivée est en outre autorisé à être transtypage vers un pointeur ou une référence à la classe de base sans ambiguïté (et vice versa), même si la classe de base est inaccessible (c'est-à-cette distribution ne tient pas compte de l'héritage privé spécificateur) . La même chose s'applique à la coulée pointeur vers le membre de pointeur vers membre du sans ambiguïté non virtuelle de base|{{c|static_cast<new_type>(expression)}}, with extensions: pointer or reference to a derived class is additionally allowed to be cast to pointer or reference to unambiguous base class (and vice versa) even if the base class is inaccessible (that is, this cast ignores the private inheritance specifier). Same applies to casting pointer to member to pointer to member of unambigous non-virtual base}}
:@c@ {{tr|{{c|static_cast}} (avec extensions), suivie par {{c|const_cast}}|{{c|static_cast}} (with extensions) followed by {{c|const_cast}}}}
:@d@ {{c|reinterpret_cast<new_type>(expression)}}
:@e@ {{tr|{{c|reinterpret_cast}} suivie {{c|const_cast}}|{{c|reinterpret_cast}} followed by {{c|const_cast}}}}
{{tr|@ @ Le premier choix qui satisfait aux exigences de l'opérateur de cast correspondant est sélectionné, même si elle ne peut pas être compilé (voir l'exemple) .|@@ The first choice that satisfies the requirements of the respective cast operator is selected, even if it cannot be compiled (see example).}}
{{tr|@ @ En outre, la notation coulé style C est autorisé à déposer à partir de, vers et entre les pointeurs de type de classe incomplète. Si les deux {{spar|expression}} et {{spar|new_type}} sont des pointeurs vers des types de classes incomplètes, il est précisé si static_cast ou reinterpret_cast obtient sélectionné .|@@ In addition, C-style cast notation is allowed to cast from, to, and between pointers to incomplete class type. If both {{spar|expression}} and {{spar|new_type}} are pointers to incomplete class types, it's unspecified whether static_cast or reinterpret_cast gets selected.}}
@2@ {{tr|La distribution fonctionnelle se compose d'un spécificateur de type simple ou un spécificateur typedef (en d'autres termes, un seul mot nom du type: {{c|unsigned int(expression)}} ou {{c|int*(expression)}} ne sont pas valides), suivie par une seule expression entre parenthèses. Cette fonte est exactement équivalente à l'expression de cast de style C correspondant .|The functional cast consists of a simple type specifier or a typedef specifier (in other words, a single-word type name: {{c|unsigned int(expression)}} or {{c|int*(expression)}} are not valid), followed by a single expression in parentheses. This cast is exactly equivalent to the corresponding C-style cast expression.}}

{{cpp/language/cast_return}}

===Exemple===
{{example
 | code=

double f = 3.14;
unsigned int n1 = (unsigned int)f; // C-style cast
unsigned int n2 = unsigned(f);     // functional cast

class C1;
class C2;
C2* foo(C1* p)
{
    return (C2*)p; // casts incomplete type to incomplete type
}

// 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
}
}}

[[de:cpp/language/explicit cast]]
[[en:cpp/language/explicit cast]]
[[es:cpp/language/explicit cast]]
[[it:cpp/language/explicit cast]]
[[ja:cpp/language/explicit cast]]
[[pt:cpp/language/explicit cast]]
[[ru:cpp/language/explicit cast]]
[[zh:cpp/language/explicit cast]]
Modèles utilisés par cette page :
Revenir à la page cpp/language/explicit cast.
cppreference.com

Rechercher

Espaces de noms

Variantes

Affichages

Actions

Voir la source de cpp/language/explicit cast

Navigation

Outils
