Quatre types de conversions dans les scénarios d'utilisation et d'utilisation C++_Basic

Conversion de type en C :

Les choses doivent commencer depuis le début, qui est le langage C. Nous sommes habitués à utiliser la conversion de type C car c'est le cas. puissant Et simple.

a principalement les deux formes suivantes :

• expression (nouveau type)

• nouveau type. (expression)

Le format de conversion de style C est très simple, mais il présente de nombreux défauts :

　1. La conversion est trop aléatoire et peut être convertie entre n'importe quel genres. Vous pouvez convertir un pointeur vers un objet const en un pointeur vers un objet non const et convertir un pointeur vers un objet de classe de base en un pointeur vers un objet de classe dérivé. L'écart entre ces conversions est très énorme, mais le langage C traditionnel. -les moulages de style ne font aucune distinction entre ceux-ci.

2. Il n'y a pas de mots-clés et d'identifiants unifiés pour la conversion de style C. Pour les grands systèmes, il est facile de l’oublier et de l’ignorer lors du dépannage du code.

Conversion de types en C++ :

Le style C++ résout parfaitement les deux problèmes ci-dessus. 1. La conversion de type est subdivisée et quatre types de conversion différents sont fournis pour prendre en charge les conversions avec des besoins différents ; 2. La conversion de type a un identifiant unifié, ce qui est pratique pour le dépannage et l'inspection du code. Les quatre conversions sont présentées ci-dessous : static_cast, Dynamic_cast, const_cast et reinterpreter_cast.

• static_cast, le nom est compris comme une conversion de type statique. Comme la conversion de int en char.

• dynamic_cast, le nom est compris comme une conversion de type dynamique. Tel que la conversion de type polymorphe entre la sous-classe et la classe parent.

• const_cast, signifie littéralement supprimer l'attribut const.

• reinterpreter_cast, réinterprète uniquement le type, mais n'effectue pas de conversion binaire.

1. Conversion static_cast

　1.Utilisation de base : expression static_cast

　2.Scénarios d'utilisation  :

a. Utilisé pour la conversion de pointeurs ou de références entre les classes de base et les classes dérivées dans la hiérarchie des classes

Conversion ascendante (classe dérivée—> classe de base) est sûr ;

Downcast (classe de base --> classe dérivée) n'est pas sûr car il n'y a pas de vérification de type dynamique.

b. Utilisé pour la conversion entre les types de données de base, comme la conversion de int en char. Cela pose des problèmes de sécurité et doit être assuré par le programmeur

c. type cible

d. Convertir tout type d'expression en type vide

3. Fonctionnalités d'utilisation

a. utilisé pour remplacer les opérations de conversion habituelles en C

b. Il est recommandé d'utiliser static_cast pour les conversions implicites pour indiquer et remplacer

int n = 6;double d = static_cast<double>(n); // 基本类型转换int *pn = &n;double *d = static_cast<double *>(&n) //无关类型指针转换，编译错误void *p = static_cast<void *>(pn); //任意类型转换成void类型

2. conversion Dynamic_cast

　1.Utilisation de base : expression Dynamic_cast

　2.Scénarios d'utilisation : Utilisez Dynamic_cast uniquement lors de la conversion entre classes dérivées, l'identifiant de type doit être un pointeur de classe, référence de classe ou void*.

　3.Fonctionnalités d'utilisation :

　a. La classe de base doit avoir une fonction virtuelle, car Dynamic_cast est une vérification de type d'exécution et nécessite des informations de type d'exécution, et ces informations. Elle est stockée dans la table des fonctions virtuelles de la classe. Seule une classe qui définit une fonction virtuelle aura une table de fonctions virtuelles (si une classe n'a pas de fonction virtuelle, au sens général, le concepteur de cette classe ne le souhaite pas). cela pour devenir une classe de base).

b. Pour la conversion vers le bas, Dynamic_cast est sûr (lorsque les types sont incohérents, le pointeur converti est un pointeur nul), tandis que static_cast n'est pas sûr (lorsque les types sont incohérents, le pointeur converti est un pointeur avec le sens erroné), peut causer divers problèmes tels que le piétinement de la mémoire et l'accès illégal)

c. Dynamic_cast peut également effectuer une conversion croisée

class BaseClass 
{public:
　　int m_iNum;
　　virtual void foo(){};//基类必须有虚函数。保持多台特性才能使用dynamic_cast};class DerivedClass: public BaseClass 
{public:
　　char *m_szName[100];
　　void bar(){};
};
　　
BaseClass* pb = new DerivedClass();
DerivedClass *pd1 = static_cast<DerivedClass *>(pb);//子类->父类，静态类型转换，正确但不推荐DerivedClass *pd2 = dynamic_cast<DerivedClass *>(pb);//子类->父类，动态类型转换，正确BaseClass* pb2 = new BaseClass();//父类->子类，静态类型转换，危险！访问子类m_szName成员越界DerivedClass *pd21 = static_cast<DerivedClass *>(pb2);//父类->子类，动态类型转换，安全的。结果是NULLDerivedClass *pd22 = dynamic_cast<DerivedClass *>(pb2);

3. conversion const_cast

　1.Utilisation de base : const_castexpression

　2.Scénarios d'utilisation :

　a Le pointeur constant est converti en non. -const pointeur et pointe toujours vers l'objet d'origine

b. La référence constante est convertie en une référence non const et pointe toujours vers l'objet d'origine

3. Utilisation des fonctionnalités  :

a , cosnt_cast est le seul opérateur de conversion parmi les quatre opérateurs de conversion de type qui peuvent opérer sur des constantes

b. Supprimer la constance est une action dangereuse, alors essayez d'éviter de l'utiliser. Un scénario spécifique est le suivant : lorsqu'une classe fournit une surcharge via const, la fonction non const appelle généralement const_cast pour convertir les paramètres en constantes, puis appelle la fonction constante, puis obtient le résultat, puis appelle const_cast pour supprimer la constance.

struct SA 
{
　　int i;
};const SA ra;//ra.i = 10; //直接修改const类型，编译错误SA &rb = const_cast<SA&>(ra);
rb.i = 10;

4. conversion reinterpret_cast

　1.Utilisation de base : reinterpret_castexpression

　2.Scénarios d'utilisation  : N'utilisez pas ce personnage de conversion en dernier recours, opérations à haut risque

　3. Fonctionnalités d'utilisation  :

a. reinterpret_cast consiste à réinterpréter le. données de la couche inférieure, selon la plate-forme spécifique, mauvaise portabilité

b. reinterpret_cast peut convertir des entiers en pointeurs, ou des pointeurs en tableaux

c. Conversion de

int doSomething(){return 0;};//FuncPtr is 一个指向函数的指针，该函数没有参数，返回值类型为 voidtypedef void(*FuncPtr)();//10个FuncPtrs指针的数组 让我们假设你希望（因为某些莫名其妙的原因）把一个指向下面函数的指针存//入funcPtrArray数组：FuncPtr funcPtrArray[10];

funcPtrArray[0] = &doSomething;// 编译错误！类型不匹配，reinterpret_cast可以让编译器以你的方法去看待它们：funcPtrArrayfuncPtrArray[0] = reinterpret_cast<FuncPtr>(&doSomething);//不同函数指针类型之间进行转换

总结：

去const属性用const_cast。

基本类型转换用static_cast。

多态类之间的类型转换用daynamic_cast。

不同类型的指针类型转换用reinterpreter_cast。

相关文章：

C++ 的强制类型转换

【c#教程】C# 类型转换

相关视频：

PHP数据类型转换之自动类型转换

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!