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_cast
les 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 , volatile
ou __unaligned
l’attributconst
.
L’opérateur static_cast
ne peut pas convertir les attributs ou volatile
__unaligned
les const
attributs. 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
Commentaires
https://aka.ms/ContentUserFeedback.
Bientôt disponible : Tout au long de 2024, nous allons supprimer progressivement GitHub Issues comme mécanisme de commentaires pour le contenu et le remplacer par un nouveau système de commentaires. Pour plus d’informations, consultezEnvoyer et afficher des commentaires pour