C ++ reinterpret_cast

Un puntatore viene sempre restituito dal reinterpret_cast. Reinterpret_cast può eseguire la cosa errata e tende a apportare la modifica appropriata al puntatore se B ha molto più di una classe astratta e A non è la prima classe astratta.

Tipo di restituzione di reinterpret_cast

Non c'è tipo di ritorno per questo. Il tipo di puntatore viene solo convertito.

Parametri di reinterpret_cast

La variabile puntatore di riferimento è l'unico argomento che accetta.

Uso di reinterpret_cast

• • L'operatore di casting reinterpret_cast è unico e problematico. Si consiglia di utilizzarlo con il tipo di dati appropriato.
  • Qualsiasi puntatore diventa un tipo di tipografie per qualche altro tipo di dati.
  • Viene utilizzato mentre si lavora con i bit.
  • Se utilizziamo reinterpret_cast, il prodotto manca della sua portabilità. Si consiglia di non impiegare questa nozione a meno che non sia strettamente essenziale.
  • È impiegato esclusivamente per il tipografico di qualsiasi puntatore al suo tipo reale.
  • Il valore booleano si trasforma in un numero binario.

Parliamo di più del C ++ Interpret_Cast.

Esempio 1:

In questo esempio, mostreremo come funziona Reinterpret_cast al suo livello più fondamentale.

#includere
Utilizzo dello spazio dei nomi std;
int main ()

int* a = new int (90);
char* chr = reinterpret_cast(UN);
cout << *a << endl;
cout << *chr << endl;
cout << a << endl;
cout << chr << endl;
restituzione 0;

Iniziamo il codice integrando il file di intestazione . Lo spazio dei nomi standard viene utilizzato nel passaggio successivo. Definiamo la funzione principale (). All'interno della funzione, costruiamo un puntatore. Insieme a questo, inizializziamo una variabile e forniamo un valore di questo puntatore.

Successivamente, dichiariamo un puntatore del tipo di dati dei caratteri. Usiamo il comando reinterpret_cast. Qui, passiamo il puntatore del personaggio. Inoltre, utilizziamo prima l'istruzione Cout per stampare il puntatore variabile e il puntatore del personaggio. Quindi, utilizziamo l'istruzione Cout per visualizzare i valori di entrambi i puntatori. Alla fine, applichiamo il comando return 0.

Esempio 2:

Questo codice dimostra come utilizzare la struttura come illustrazione.

#includere
Utilizzo dello spazio dei nomi std;
struct mystruct
int i;
int j;
fascino;
bool n;
;
int main ()

mystruct e;
e.i = 25;
e.j = 40;
e.m = 'u';
e.n = vero;
int* ptr = reinterpret_cast(& e);
cout << sizeof (e) << endl;
cout << *ptr << endl;
PTR ++;
cout << *ptr << endl;
PTR ++;
char* chr = reinterpret_cast(PTR);
cout << *chr << endl;
Chr ++;
bool* b = reinterpret_cast(CHR);
cout << *b << endl;
cout << *(reinterpret_cast(Chr));
restituzione 0;

Lo spazio dei nomi della libreria e standard vengono utilizzati all'inizio del codice. Creiamo una struttura definita mystruct. All'interno di questa struttura, inizializziamo due variabili denominate I e J. Quindi, creiamo altre due variabili da cui la prima variabile ha un tipo di dati di caratteri e la seconda variabile ha un tipo di dati booleano. Nel passaggio successivo, utilizziamo la funzione principale (). All'interno di questa funzione, chiamiamo una variabile "E" della struttura "Mystruct".

Quindi, assegniamo alcuni valori casuali alla variabile associata alla struttura. Le prime due variabili contengono i valori interi. La terza variabile contiene il carattere. L'ultima variabile contiene il valore booleano. Durante il casting, il tipo di dati della variabile è uguale a quello della variabile reale. Ora, convertiamo il puntatore di "E" al puntatore della variabile con il tipo di dati interi. Costruiamo il puntatore e impostiamo il suo valore uguale a reinterpret_cast. Quindi, utilizziamo l'istruzione Cout. Incrediamo il valore del puntatore "PTR" di 1. Ora, stampiamo il valore del prossimo puntatore, quindi utilizziamo di nuovo l'istruzione Cout.

Inoltre, il valore di questo puntatore è aumentato di 1. Applichiamo il casting al puntatore del personaggio "Chr" mediante l'uso di reinterpret_cast. Ora, mostra solo il valore del puntatore del personaggio con l'aiuto della dichiarazione Cout. Poiché *Chr corrisponde già a un valore booleano, viene utilizzata una trasformazione di tipo di dati simile per ottenere il valore. Pertanto, utilizziamo il tipo di dati *B, che è un bool. Utilizziamo reinterpret_cast per il puntatore booleano. Stampiamo il valore di quella variabile booleana applicando l'istruzione Cout. Reinterpret_cast è impiegato per visualizzare il valore indicato dal *Chr. Per terminare il codice, utilizzare l'istruzione return 0.

Esempio 3:

Il puntatore reinterpreta è dimostrato in questo caso.

#includere
Utilizzo dello spazio dei nomi std;
class u
pubblico:
void fun_x ()

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

;
Classe V
pubblico:
void fun_b ()

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

;
int main ()

V* i = new v ();
V* new_x = reinterpret_cast(io);
new_x-> fun_x ();
restituzione 0;

Prima di tutto, introduciamo il modulo e lo spazio dei nomi standard. Quindi costruiamo una classe chiamata U. Definiamo pubblicamente una funzione di questa classe. Utilizziamo il comando cout all'interno di questa funzione. Quindi, facciamo una nuova classe chiamata V. Dopo aver chiamato la funzione, la rendiamo pubblica. Qui, viene utilizzata l'istruzione Cout. Iniziamo la codifica all'interno del metodo principale (). Innanzitutto, costruiamo l'oggetto "io" della classe V. Trasformiamo il puntatore sull'oggetto e diamo il riferimento della classe V alla classe U, quindi utilizziamo reinterpret_cast. Successivamente, recupiamo la funzione "Fun_x" della classe u. Quindi, applica il comando return 0 per terminare il programma.

Conclusione

Abbiamo discusso di C ++ reinterpret_cast in questo articolo. C'è un operatore di casting chiamato reinterpret_cast in c++. Non importa se le classi sono connesse o meno, viene utilizzato per trasformare un puntatore di un tipo di dati in qualche altro puntatore. Abbiamo valutato tre esempi e in uno di essi, possiamo vedere come usare reinterpret_cast funziona nella sua forma più elementare. Nel secondo esempio, utilizziamo una struttura e quindi utilizziamo reinterpret_cast per cambiare il suo puntatore su un altro puntatore. L'ultima illustrazione mostra un puntatore reinterpretato.