Les opérateurs de conversion sont utilisés pour la conversion de type en C++. Ils sont utilisés pour convertir un type de données en un autre. C++ prend en charge quatre types de conversions :

1. static_cast
2. dynamique_cast
3. const_cast
4. réinterpréter_cast

1. static_cast

Le static_cast L’opérateur est l’opérateur de casting le plus couramment utilisé en C++. Il effectue une conversion de type au moment de la compilation et est principalement utilisé pour les conversions explicites considérées comme sûres par le compilateur.

Syntaxe de static_cast

  static_cast   <  new_type>(expression);>

où,

'abc' est en chiffres'

• expression: Données à convertir.
• nouveau genre: Type d'expression souhaité

Le static_cast peut être utilisé pour convertir entre des types associés, tels que des types numériques ou des pointeurs dans la même hiérarchie d'héritage.

Exemple de static_cast

// C++ program to illustrate the static_cast #include  #include  using namespace std; int main() { int num = 10; // converting int to double double numDouble = static_cast(nombre); // impression du type de données cout<< typeid(num).name() << endl; // typecasting cout << typeid(static_cast(num)).nom()<< endl; // printing double type t cout << typeid(numDouble).name() << endl; return 0; }>

i d d>

Dans cet exemple, nous avons inclus le typeinfo bibliothèque afin que nous puissions utiliser identifiant de type() fonction pour vérifier le type de données. Nous avons défini une variable entière 'num' et l'avons convertie en double à l'aide de static_cast. Après cela, nous imprimons les types de données des variables et passons static_cast(num) dans identifiant de type() fonction pour vérifier son type de données. nous pouvons voir la sortie i, d, d est imprimée où 'je' désigne entier et 'd' désigne double .

commentaire css

2. dynamique_cast

Le dynamique_cast L’opérateur est principalement utilisé pour effectuer un downcasting (conversion d’un pointeur/référence d’une classe de base en une classe dérivée). Il garantit la sécurité du type en effectuant une vérification d'exécution pour vérifier la validité de la conversion.

Syntaxe de Dynamic_cast

  dynamic_cast   <  new_type>(expression);>

Si la conversion n'est pas possible, dynamique_cast renvoie un pointeur nul (pour les conversions de pointeurs) ou lance un exception bad_cast (pour les conversions de référence).

Exemple de Dynamic_cast

// C++ program to illustrate the dynamic_cast #include  using namespace std; // Base Class class Animal { public: virtual void speak() const { cout << 'Animal speaks.' << endl; } }; // Derived Class class Dog : public Animal { public: void speak() const override { cout << 'Dog barks.' << endl; } }; // Derived Class class Cat : public Animal { public: void speak() const override { cout << 'Cat meows.' << endl; } }; int main() { // base class pointer to derived class object Animal* animalPtr = new Dog(); // downcasting Dog* dogPtr = dynamic_cast(animalPtr); // vérifie si le transtypage réussit if (dogPtr) { dogPtr->speak(); } autre { cout<< 'Failed to cast to Dog.' << endl; } // typecasting to other dervied class Cat* catPtr = dynamic_cast(animalPtr); if (catPtr) { catPtr->parler(); } autre { cout<< 'Failed to cast to Cat.' << endl; } delete animalPtr; return 0; }>

Dog barks. Failed to cast to Cat.>

Explication: La première ligne de sortie est imprimée car le 'animalPtr' de la 'Animal' le type est correctement converti en 'Chien' tapez et parler() la fonction de la classe Dog est invoquée mais le casting du 'Animal' tapez pour 'Chat' le type a échoué parce que 'animalPtr' pointe vers un 'Chien' objet ainsi, la conversion dynamique échoue car la conversion de type n'est pas sûre.

3. const_cast

Le const_cast L’opérateur est utilisé pour modifier le qualificatif const ou volatile d’une variable. Il permet aux programmeurs de supprimer temporairement la constance d'un objet et d'y apporter des modifications. Il faut être prudent lors de l'utilisation de const_cast, car la modification d'un objet const peut conduire à un comportement indéfini.

lancer la gestion des exceptions en Java

Syntaxe pour const_cast

  const_cast   <  new_type>(expression);>

Exemple de const_cast

// C++ program to illustrate the const_cast #include  using namespace std; int main() { const int number = 5; // Pointer to a const int const int* ptr = &number; // int* nonConstPtr = ptr; if we use this // instead of without using const_cast // we will get error of invalid conversion int* nonConstPtr = const_cast (ptr); *nonConstPtr = 10 ; cout<< 'Modified number: ' << *nonConstPtr; return 0; }>

Modified number: 10>

Dans l'exemple ci-dessus, nous avons modifié la valeur du type const pointeur en changeant son qualificatif de const à non-const puis imprimer la valeur modifiée.

4. réinterpréter_cast

Le opérateur réinterpréter_cast est utilisé pour convertir le pointeur en tout autre type de pointeur. Il n'effectue aucune vérification si le pointeur converti est du même type ou non.

Syntaxe de reinterpret_cast

  reinterpret_cast   <  new_type>(expression);>

Exemple

// C++ program to illustrate the reinterpret_cast #include  using namespace std; int main() { int number = 10; // Store the address of number in numberPointer int* numberPointer = &number; // Reinterpreting the pointer as a char pointer char* charPointer = reinterpret_cast(numéroPointeur); // Impression des adresses mémoire et des valeurs cout<< 'Integer Address: ' << numberPointer << endl; cout << 'Char Address: ' << reinterpret_cast(charPointer)<< endl; return 0; }>

Integer Address: 0x7fff64789f1c Char Address: 0x7fff64789f1c>

Dans l'exemple ci-dessus, nous avons défini une variable int 'nombre' puis stockez l'adresse du « numéro » dans 'numéroPointeur' du type int après quoi nous avons converti le 'numéroPointeur' du type int dans le pointeur char, puis stockez-le dans 'charPointer' variable. Pour vérifier que nous avons imprimé l’adresse de numberPointer et de charPointer. Pour imprimer l'adresse stockée dans 'charPointer' réinterpréter_cast est utilisé pour contourner le mécanisme de vérification de type de C++ et permettre au pointeur d'être imprimé en tant qu'adresse mémoire générique sans aucune interprétation spécifique au type.

Note: const_cast et reinterpret_cast ne sont généralement pas recommandés car ils sont vulnérables à différents types d'erreurs.