static_cast, opérateur

Convertit une expression en type id, en fonction uniquement des types présents dans l’expression.

Syntaxe

static_cast <type-id> ( expression )

Notes

Dans C++ standard, aucun contrôle de type à l'exécution n'est fait pour garantir la sécurité de la conversion. Dans C++/CX, il est procédé à un calcul du temps de compilation et à un contrôle à l'exécution. Pour plus d'informations, consultez Cast.

L’opérateur static_cast peut être utilisé pour les opérations telles que la conversion d’un pointeur en classe de base en pointeur vers une classe dérivée. Ces conversions ne sont pas toujours sûres.

En général, vous utilisez static_cast quand vous souhaitez convertir des types de données numériques tels que des énumérations en ints ou des ints en floats, et que vous êtes certain des types de données impliqués dans la conversion. static_castles conversions ne sont pas aussi sécurisées que dynamic_cast les conversions, car static_cast aucun type d’exécution n’case activée, tandis que dynamic_cast cela. Un dynamic_cast pointeur ambigu échouera, tandis qu’un static_cast retour comme si rien n’était incorrect ; cela peut être dangereux. Bien que dynamic_cast les conversions soient plus sécurisées, dynamic_cast seules fonctionnent sur des pointeurs ou des références, et le type d’exécution case activée est une surcharge. Pour plus d’informations, consultez dynamic_cast Opérateur.

Dans l'exemple qui suit, la ligne D* pd2 = static_cast<D*>(pb); n'est pas sécurisée 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 le 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, aucune case activée au moment de l’exécution n’est effectuée sur la static_cast conversion de pb. L'objet pointé par pb peut ne pas être un objet de type D, auquel cas l'utilisation de *pd2 peut être désastreuse. Par exemple, appeler une fonction membre de la classe D, mais pas de la classe B, peut entraîner une violation d'accès.

Les dynamic_cast opérateurs déplacent static_cast un pointeur dans une hiérarchie de classes. Toutefois, static_cast s’appuie exclusivement sur les informations fournies dans l’instruction cast et peut donc être dangereuse. 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 pb pointe vraiment sur un objet de type D, alors pd1 et pd2 reçoivent la même valeur. Ils auront également la même valeur si pb == 0.

Si pb elle pointe vers un objet de type B et non à la classe complète D , dynamic_cast elle saura suffisamment pour retourner zéro. Toutefois, static_cast s’appuie sur l’assertion du programmeur qui pb pointe vers un objet de type D et retourne simplement un pointeur vers cet objet supposé D .

Par conséquent, static_cast peut effectuer l’inverse des conversions implicites, auquel cas les résultats ne sont pas définis. Il est laissé au programmeur pour vérifier que les résultats d’une static_cast conversion sont sûrs.

Ce comportement s'applique également aux types autres que les types de classe. Par exemple, static_cast vous pouvez utiliser la conversion d’un int en un char. Toutefois, le résultat char peut ne pas avoir suffisamment de bits pour contenir la valeur entière int . Là encore, il est laissé au programmeur de vérifier que les résultats d’une static_cast conversion sont sûrs.

L’opérateur static_cast peut également être utilisé pour effectuer toute 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 static_cast peut convertir explicitement une valeur intégrale en type d’énumération. Si la valeur du type entier ne fait pas partie de la plage des valeurs d'énumération, la valeur d'énumération résultante n'est pas définie.

L’opérateur static_cast convertit une valeur de pointeur Null en valeur de pointeur Null du type de destination.

Toute expression peut être convertie explicitement en type void par l’opérateur static_cast . Le type void de destination peut éventuellement inclure le , volatileou __unaligned l’attributconst.

L’opérateur static_cast ne peut pas convertir les attributs ou volatile__unaligned les constattributs. Pour plus d’informations sur la suppression de ces attributs, consultez const_cast Opérateur .

C++/CLI : en raison du danger d’effectuer des casts non case activée sur un garbage collector déplacé, l’utilisation de static_cast ne doit être utilisée que dans le code critique pour les performances lorsque vous êtes certain qu’elle fonctionnera correctement. Si vous devez utiliser static_cast en mode mise en production, remplacez-le par safe_cast dans vos builds de débogage pour garantir la réussite.

Voir aussi

Opérateurs de casting
Mots clés