opérateur de static_cast
Convertit expression au type de type-identificateur, a uniquement sur les types qui sont présents dans l'expression.
static_cast <type-id> ( expression )
Notes
Aucun contrôle de type d'exécution n'est effectué pour garantir la sécurité de la conversion.
L'opérateur d' static_cast peut être utilisé pour des opérations telles que convertir un pointeur vers une classe de base en un pointeur vers une classe dérivée.De ces conversions ne sont pas toujours sûres.
En général vous utilisez static_cast lorsque vous souhaitez convertir des types de données numériques tels que les enums aux ints ou les ints aux floats, et vous êtes certain des types de données impliqués dans la conversion.les conversions d'static_cast ne sont pas aussi sécurisées que les conversions d' dynamic_cast , car static_cast ne fait aucun contrôle de type d'exécution, alors qu' dynamic_cast fait.dynamic_cast à un pointeur ambigu échouera, alors qu' static_cast retourne comme si rien n'étaient erroné ; cela peut être dangereux.Bien que les conversions d' dynamic_cast soient plus sécurisées, dynamic_cast fonctionne uniquement sur les pointeurs ou des références, et le contrôle du type d'exécution est une charge mémoire.Pour plus d'informations, consultez opérateur de dynamic_cast.
Dans l'exemple qui suit, la ligne D* pd2 = static_cast<D*>(pb); est déconseillé car D peut avoir des champs et des méthodes qui ne sont pas dans B.Toutefois, la ligne B* pb2 = static_cast<B*>(pd); est une conversion sûre car D contient toujours tout l' B.
// static_cast_Operator.cpp
// compile with: /LD
class B {};
class D : public B {};
void f(B* pb, D* pd) {
D* pd2 = static_cast<D*>(pb); // Not safe, D can have fields
// and methods that are not in B.
B* pb2 = static_cast<B*>(pd); // Safe conversion, D always
// contains all of B.
}
Contrairement à dynamic_cast, aucun contrôle à l'exécution n'est effectué sur la conversion d' static_cast d' pb.L'objet sur lequel pointe pb peut ne pas être un objet de type D, auquel cas l'utilisation d' *pd2 peut être désastreuse.Par exemple, appeler une fonction membre de la classe d' D , mais pas la classe d' B , peut entraîner une violation d'accès.
Les opérateurs d' dynamic_cast et d' static_cast passent un pointeur dans une hiérarchie de classes.Toutefois, static_cast dépend exclusivement sur les informations fournies dans l'instruction de cast et peut donc être potentiellement dangereux.Par exemple :
// static_cast_Operator_2.cpp
// compile with: /LD /GR
class B {
public:
virtual void Test(){}
};
class D : public B {};
void f(B* pb) {
D* pd1 = dynamic_cast<D*>(pb);
D* pd2 = static_cast<D*>(pb);
}
si d' pb les points vraiment à un objet de type D, puis pd1 et pd2 obtiendront la même valeur.Ils seront également la même valeur si pb == 0.
Si les points d' pb à un objet de type B et non la classe complète d' D , alors dynamic_cast connaîtront suffisant pour retourner zéro.Toutefois, static_cast repose sur l'assertion du programmeur que les points d' pb à un objet de type D et retourne simplement un pointeur vers cet objet supposé d' D .
Par conséquent, static_cast peut faire l'inverse des conversions implicites, auquel cas les résultats sont indéfinis.Il est autorisé au programmeur pour vérifier que les résultats d'une conversion d' static_cast est sécurisé.
Ce comportement s'applique également aux types autres que les types de classe.Par exemple, static_cast peut être utilisé pour convertir d'un int par char.Toutefois, char résultant peut ne pas avoir suffisamment de bits pour contenir la valeur entière d' int .Là encore, il se trouve au programmeur pour vérifier que lesrésultats d'une conversion d'static_cast est sécurisé.
L'opérateur d' static_cast peut également être utilisé pour effectuer une conversion implicite, y compris les conversions standard et les conversions définies par l'utilisateur.Par exemple :
// static_cast_Operator_3.cpp
// compile with: /LD /GR
typedef unsigned char BYTE;
void f() {
char ch;
int i = 65;
float f = 2.5;
double dbl;
ch = static_cast<char>(i); // int to char
dbl = static_cast<double>(f); // float to double
i = static_cast<BYTE>(ch);
}
L'opérateur d' static_cast peut convertir explicitement une valeur intégrale à un type énumération.Si la valeur du type intégral ne fait pas partie de la plage de valeurs d'énumération, la valeur d'énumération résultant est pas définie.
L'opérateur d' static_cast convertit une valeur de pointeur null à la valeur du pointeur null du type de destination.
Toute expression peut être explicitement convertie en type void par l'opérateur d' static_cast .Le type void de destination peut éventuellement inclure const, volatile, ou l'attribut d' __unaligned .
L'opérateur d' static_cast ne peut pas effectuer un cast loin const, volatile, les attributs ou d' __unaligned .Consultez l' opérateur de const_cast pour plus d'informations sur supprimer ces attributs.
En raison de le risque d'effectuer des casts non vérifiées (unchecked) sur un garbage collector déplaçant, l'utilisation d' static_cast doit être uniquement dans le code représentation-critique lorsque vous êtes certain qu'il fonctionne correctement.Si vous devez utiliser static_cast en mode release, substituez-le avec safe_cast dans vos versions debug pour garantir la réussite.