C ++ reinterpret_cast

Ein Zeiger wird immer vom neu interpret_cast zurückgegeben. Reinterpret_cast kann das falsche Ding ausführen und neigt dazu, den Zeiger entsprechend zu ändern, wenn B viel mehr als eine abstrakte Klasse hat und A nicht die erste abstrakte Klasse ist.

Rückgabetyp des reinterpret_casts

Es gibt keinen Rückgabetyp dafür. Der Zeigertyp wird nur konvertiert.

Parameter des neuinterpret_casts

Die Referenzzeigervariable ist das einzige Argument, das sie akzeptiert.

Verwendung von neu interpret_cast

• • Der Casting -Operator reinterpret_cast ist ein einzigartiges und problematisches. Es wird empfohlen, es mit dem entsprechenden Datentyp zu verwenden.
  • Jeder Zeiger wird zu einem anderen Datentyp zu einem Typecast.
  • Es wird bei der Arbeit mit Bits verwendet.
  • Wenn wir den reinterpret_cast verwenden, fehlt dem Produkt seine Portabilität. Es wird empfohlen, diesen Begriff nicht zu verwenden, es sei denn, er ist streng wichtig.
  • Es wird ausschließlich verwendet.
  • Der Boolesche Wert wird in eine Binärzahl umgewandelt.

Sprechen wir mehr über den c ++ interpretation_cast.

Beispiel 1:

In diesem Beispiel werden wir zeigen, wie die reinterpret_cast auf seiner grundlegendsten Ebene funktioniert.

#enthalten
Verwenden von Namespace STD;
int main ()

int* a = new int (90);
char* chr = neu interpret_cast(A);
Cout << *a << endl;
Cout << *chr << endl;
Cout << a << endl;
Cout << chr << endl;
Rückkehr 0;

Wir starten den Code, indem wir die Header -Datei integrieren . Der Standard -Namespace wird im nächsten Schritt verwendet. Wir definieren die main () -Funktion. Innerhalb der Funktion konstruieren wir einen Zeiger. Zusammen mit diesem initialisieren wir eine Variable und geben einen Wert dieses Zeigers.

Als nächstes deklarieren wir einen Zeiger des Zeichendatentyps. Wir verwenden den Befehl neu interpret_cast. Hier passieren wir den Charakterzeiger. Darüber hinaus verwenden wir die Cout -Anweisung zuerst, um den variablen Zeiger sowie den Charakterzeiger zu drucken. Dann verwenden wir die Cout -Anweisung, um die Werte beider Zeiger anzuzeigen. Am Ende wenden wir den Befehl return 0 an.

Beispiel 2:

Dieser Code zeigt, wie die Struktur als Illustration verwendet wird.

#enthalten
Verwenden von Namespace STD;
Struktur Mystruct
int i;
int j;
Charme;
bool n;
;
int main ()

Mystruct E;
e.i = 25;
e.J = 40;
e.m = 'u';
e.n = wahr;
int* ptr = neuinterpret_cast(& e);
Cout << sizeof (e) << endl;
Cout << *ptr << endl;
ptr ++;
Cout << *ptr << endl;
ptr ++;
char* chr = neu interpret_cast(PTR);
Cout << *chr << endl;
chr ++;
bool* b = neu interpret_cast(chr);
Cout << *b << endl;
Cout << *(reinterpret_cast(chr));
Rückkehr 0;

Der Bibliothek und der Standard -Namespace werden zu Beginn des Codes verwendet. Wir erstellen eine Struktur, die als MYSstruct bezeichnet wird. Innerhalb dieser Struktur initialisieren wir zwei Variablen mit dem Namen I und J. Anschließend erstellen wir zwei weitere Variablen, aus denen die erste Variable einen Zeichendatentyp hat und die zweite Variable einen Booleschen Datentyp hat. Im späteren Schritt verwenden wir die main () -Funktion. In dieser Funktion nennen wir eine Variable "E" der Struktur "Mystruct".

Dann weisen wir der mit der Struktur zugeordneten Variablen einige zufällige Werte zu. Die ersten beiden Variablen enthalten die Ganzzahlwerte. Die dritte Variable enthält das Zeichen. Die letzte Variable enthält den booleschen Wert. Während des Castings ist der Datentyp der Variablen der gleiche wie der der realen Variablen. Jetzt konvertieren wir den Zeiger von „E“ in den Zeiger der Variablen mit dem Ganzzahl -Datentyp. Wir konstruieren den Zeiger und setzen seinen Wert gleich dem reinterpret_cast. Dann verwenden wir die Cout -Erklärung. Wir erhöhen den Wert des Zeigers „PTR“ um 1. Jetzt drucken wir den Wert des nächsten Zeigers, also verwenden wir die Cout -Erklärung erneut.

Zusätzlich wird der Wert dieses Zeigers durch 1 erhöht. Wir wenden das Casting durch die Verwendung von reinterpret_cast auf den Zeiger des Charakters „CHR“ an. Zeigen Sie nun einfach den Wert des Charakterzeigers mit Hilfe der Cout -Erklärung an. Da *CHR bereits einem booleschen Wert entspricht, wird eine ähnliche Datentyp -Transformation verwendet, um den Wert zu erhalten. Somit verwenden wir den Datentyp *B, der ein Bool ist. Wir verwenden den neuinterpret_cast für den booleschen Zeiger. Wir drucken den Wert dieser booleschen Variablen, indem wir die Cout -Anweisung anwenden. Der neuinterpret_cast wird verwendet, um den von dem *chrm gezeigten Wert anzuzeigen. Verwenden Sie zur Beendigung des Code.

Beispiel 3:

Die Neuinterpretation des Zeigers wird in diesem Fall demonstriert.

#enthalten
Verwenden von Namespace STD;
Klasse u
öffentlich:
void Fun_x ()

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

;
Klasse V
öffentlich:
void Fun_b ()

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

;
int main ()

V* i = new v ();
V* new_x = neuinterpret_cast(ich);
new_x-> fun_x ();
Rückkehr 0;

Zunächst stellen wir das Modul und den Standard -Namespace vor. Dann konstruieren wir eine Klasse namens U. Wir definieren eine Funktion dieser Klasse öffentlich. Wir verwenden den COUT -Befehl innerhalb dieser Funktion. Dann machen wir eine neue Klasse namens v. Nachdem wir die Funktion aufgerufen haben, machen wir sie öffentlich. Hier wird die Cout -Anweisung verwendet. Wir beginnen die Codierung innerhalb der Main () -Methode. Zuerst konstruieren wir das Objekt "I" von Klasse V. Wir verwandeln den Zeiger in das Objekt und geben die Referenz der Klasse V auf die Klasse U, sodass wir den neuinterpret_cast verwenden. Als nächstes holen wir die Funktion "Fun_x" der Klasse U. Wenden Sie dann den Befehl return 0 an, um das Programm zu beenden.

Abschluss

Wir haben in diesem Artikel den c ++ reinterpret_cast besprochen. Es gibt einen Casting -Operator namens neuinterpret_cast in C++. Egal, ob die Klassen verbunden sind oder nicht, es wird verwendet, um einen Zeiger eines Datentyps in einen anderen Zeiger zu verwandeln. Wir haben drei Beispiele bewertet und in einem von ihnen können wir sehen. Im zweiten Beispiel verwenden wir eine Struktur und verwenden dann den neuinterpret_cast, um seinen Zeiger in einen anderen Zeiger zu ändern. Die letzte Illustration zeigt eine Neuinterpretation eines Zeigers.