C ++ reinterpret_cast

Un pointeur est toujours renvoyé par le reinterpret_cast. Reinterpret_cast peut exécuter la chose incorrecte et a tendance à apporter la modification appropriée au pointeur si B a bien plus qu'une classe abstraite et A n'est pas la première classe abstraite.

Retourner le type de reinterpret_cast

Il n'y a pas de type de retour pour ça. Le type de pointeur n'est converti que.

Paramètres du reinterpret_cast

La variable du pointeur de référence est le seul argument qu'il accepte.

Utilisation de Reinterpret_cast

• • L'opérateur de coulée Reinterpret_cast est unique et problématique. Il est recommandé de l'utiliser avec le type de données approprié.
  • Tout pointeur devient une dactylographie à un autre type de données.
  • Il est utilisé en travaillant avec des bits.
  • Si nous utilisons le Reinterpret_cast, le produit n'a pas sa portabilité. Il est recommandé de ne pas utiliser cette notion à moins qu'elle ne soit strictement essentielle.
  • Il est exclusivement utilisé pour la mise en cappe de tout pointeur vers son type réel.
  • La valeur booléenne est transformée en un numéro binaire.

Parlons plus du C ++ Interprét_cast.

Exemple 1:

Dans cet exemple, nous allons montrer comment les fonctions Reinterpret_cast à son niveau le plus fondamental.

#inclure
Utilisation de Namespace Std;
int main()

int * a = new int (90);
char * ch = reinterpret_cast(un);
couter << *a << endl;
couter << *chr << endl;
couter << a << endl;
couter << chr << endl;
retour 0;

Nous commençons le code en intégrant le fichier d'en-tête . L'espace de noms standard est utilisé à l'étape suivante. Nous définissons la fonction principale (). Dans la fonction, nous construisons un pointeur. Parallèlement à cela, nous initialisons une variable et fournissons une valeur de ce pointeur.

Ensuite, nous déclarons un pointeur du type de données de caractère. Nous utilisons la commande reinterpret_cast. Ici, nous passons le pointeur de personnage. De plus, nous utilisons d'abord l'instruction COUT pour imprimer le pointeur variable ainsi que le pointeur de caractère. Ensuite, nous utilisons l'instruction COUT pour afficher les valeurs des deux pointeurs. En fin de compte, nous appliquons la commande return 0.

Exemple 2:

Ce code montre comment utiliser la structure comme illustration.

#inclure
Utilisation de Namespace Std;
struct mystruct
int i;
Int J;
charme;
bool n;
;
int main()

mystruct e;
e.i = 25;
e.J = 40;
e.m = 'u';
e.n = true;
int * ptr = reinterpret_cast(& e);
couter << sizeof (e) << endl;
couter << *ptr << endl;
ptr ++;
couter << *ptr << endl;
ptr ++;
char * ch = reinterpret_cast(ptr);
couter << *chr << endl;
chr ++;
bool * b = reinterpret_cast(Chr);
couter << *b << endl;
couter << *(reinterpret_cast(Chr));
retour 0;

La bibliothèque et l'espace de noms standard sont utilisés au début du code. Nous créons une structure appelée mystruct. Dans cette structure, nous initialisons deux variables nommées I et J. Ensuite, nous créons deux autres variables à partir desquelles la première variable a un type de données de caractère et la deuxième variable a un type de données booléen. Dans l'étape ultérieure, nous utilisons la fonction principale (). À l'intérieur de cette fonction, nous appelons une variable «e» de la structure «mystruct».

Ensuite, nous attribuons des valeurs aléatoires à la variable associée à la structure. Les deux premières variables contiennent les valeurs entières. La troisième variable contient le caractère. La dernière variable contient la valeur booléenne. Pendant la coulée, le type de données de la variable est le même que celui de la variable réelle. Maintenant, nous convertissons le pointeur de «e» en pointeur de la variable ayant le type de données entier. Nous construisons le pointeur et définissons sa valeur égale à la reinterpret_cast. Ensuite, nous utilisons l'instruction COUT. Nous incrémentons la valeur du pointeur «ptr» par 1. Maintenant, nous imprimons la valeur du pointeur suivant, nous utilisons donc à nouveau la déclaration COUT.

De plus, la valeur de ce pointeur est augmentée par 1. Nous appliquons le casting sur le pointeur du personnage «Chr» par l'utilisation de Reinterpret_cast. Maintenant, montrez simplement la valeur du pointeur de personnage à l'aide de l'instruction COUT. Comme * Chr correspond déjà à une valeur booléenne, une transformation de type de données similaire est utilisée pour obtenir la valeur. Ainsi, nous utilisons le type de données * B, qui est un bool. Nous utilisons le reinterpret_cast pour le pointeur booléen. Nous imprimons la valeur de cette variable booléenne en appliquant l'instruction COUT. Le reinterpret_cast est utilisé pour afficher la valeur pointée par le * Chr. Pour résilier le code, utilisez l'instruction RETOUR 0.

Exemple 3:

La réinterprétation du pointeur est démontrée dans ce cas.

#inclure
Utilisation de Namespace Std;
classe u
public:
void fun_x ()

couter << " Present in class U\n";

;
classe V
public:
void fun_b ()

couter << " Present in class V\n";

;
int main()

V * i = new v ();
V * new_x = reinterpret_cast(je);
new_x-> fun_x ();
retour 0;

Tout d'abord, nous présentons le module et l'espace de noms standard. Ensuite, nous construisons une classe nommée vous. Nous définissons publiquement une fonction de cette classe. Nous utilisons la commande cout dans cette fonction. Ensuite, nous faisons une nouvelle classe appelée V. Après avoir appelé la fonction, nous le rendons publics. Ici, l'instruction COUT est utilisée. Nous commençons le codage à l'intérieur de la méthode principale (). Tout d'abord, nous construisons l'objet «I» de la classe V. Nous transformons le pointeur en l'objet et donnons la référence de la classe V en classe U, nous utilisons donc la reinterpret_cast. Ensuite, nous récupérons la fonction «fun_x» de la classe U. Ensuite, appliquez la commande return 0 pour mettre fin au programme.

Conclusion

Nous avons discuté du C ++ Reinterpret_cast dans cet article. Il y a un opérateur de casting nommé Reinterpret_cast en C++. Peu importe si les classes sont connectées ou non, il est utilisé pour transformer un pointeur d'un type de données en un autre pointeur. Nous avons évalué trois exemples et dans l'un d'eux, nous pouvons voir comment utiliser le Reinterpret_cast fonctionne sous sa forme la plus élémentaire. Dans le deuxième exemple, nous utilisons une structure, puis utilisons la reinterpret_cast pour changer son pointeur en un autre pointeur. La dernière illustration montre une réinterpréter du pointeur.