Bevor wir das Konzept der Bad_Weak_Ptr -Klasse verstehen, müssen wir wissen, was gemeinsame Zeiger und schwache Zeiger sind. Gemeinsame Zeiger sind diejenigen, in denen wir den Zeiger in verschiedenen Variablen kopieren können. Wir können sagen, dass gemeinsame Zeiger gemeinsame Besitz haben, wenn der schwache Zeiger selbst keine Eigentümerin hat. Das Bad_Weak_PTR ist die eingebaute Klasse, die vom Standard C bereitgestellt wird++. Es ist derjenige, der verwendet wird, um das Objekt als Ausnahme durch den Konstruktor der gemeinsamen Zeiger zu werfen, und nimmt den schwachen Zeiger als Argument. Der schwache Zeiger selbst bezieht sich auf ein gelöschtes Objekt.

Syntax:

Nachfolgend ist die Syntax zum Erstellen der Ausnahme von Bad_Weak_Ptr -Klasse zu erstellen.

Klasse bad_weak_ptr: public std :: Ausnahme
bad_weak_ptr ();
const char *was () throw ();
;

Diese Klasse definiert eine Ausnahme, die wir mit dem gemeinsam genutzten Zeigerkonstruktor werfen können, der das Argument der Art des schwachen Zeigers hält. In der Syntax ist die obige Ausnahme der Fehler, den wir werfen werden, während der schlechte schwache Zeiger auftritt. In der Klassenfunktion haben wir zwei Funktionen des Datentyps konstanter Zeichen deklariert, die die Methode „What ()“ und die „Throw ()“ sind. Die Funktion „What ()“ wird verwendet, um das beendetes Zeichen zurückzugeben, das die verwendete Ausnahme identifiziert, und der „Throw ()“ wird verwendet, um die Ausnahme zu werfen, wenn der Compiler das Problem erkennt. Der Rückgabewert für den schlechten schwachen Zeiger ist die null-terminierte Zeichenfolge mit der Erklärung.

Beispiel # 01:

Lassen Sie uns nun ein Beispiel für Bad_Weak_ptr durchführen, um zu überprüfen, wie es funktioniert. Der erste Schritt, um hier auszuführen, besteht darin, die Header -Dateien "ioStrem" und den „Speicher“ einzuschließen, und die „Speicher“ einbeziehen. Das „iOstream“ bietet die Möglichkeit, Eingabe-Output-Vorgänge durchzuführen. Während wir mit dem „Speicher“ verschiedene Operationen im Zusammenhang mit der Speicherzuweisung usw. ausführen können, usw.

In der Hauptfunktion haben wir nun einen gemeinsamen Zeiger des Ganzzahl -Typs mit dem Namen "PTR" deklariert, der den Namen "PTR" hat. An diesem Zeiger haben wir den Ganzzahlwert „42“ übergeben und mit dem neuen Schlüsselwort den Speicherhaufen zugeteilt. Und dann haben wir mit dem schwachen Zeiger einen Bad_Weak_ptr mit dem Namen "Bad_Weak_Pointer" deklariert, auf den wir den gemeinsam genutzten Zeiger "PTR" verwiesen haben. Mit dem Schlüsselwort reset () werden wir nun die Bits auf dem bereitgestellten Index von „PTR“ auf NULL oder „0“ zurücksetzen. Als nächst. Im Inneren haben wir einen weiteren gemeinsamen Zeiger mit dem Namen "P2" deklariert, der den schlechten schwachen Zeiger "Bad_Weak_Pointer" halten wird. Jetzt nennen wir die Anweisung catch (), mit der wir den Ausführungblock bei jedem Fehler definieren können. An die Anweisung catch () haben wir die bad_weak_ptr und das "err" als Parameter übergeben. Das „ERR“ wird verwendet, um den Fehler zu halten, der in diesem Programm auftritt. In der Variablen „ERR“ in der Curly -Zahnspangen zeigt die in diesem Code auftretende Fehlertyps mit der Methode What () an, mit der die Anweisung, die den Fehler identifiziert.

#enthalten
#enthalten
int main ()

std :: shared_ptr ptr (neu int (42));
STD :: WACK_PTR BAD_WEAK_POINGER (PTR);
ptr.zurücksetzen();
versuchen
STD :: SHARED_PTR P2 (Bad_Weak_Pointer);
catch (const std :: bad_weak_ptr & err)
std :: Cout << err.what() << '\n';

Lassen Sie uns nun unsere Ausgabe überprüfen, in der ein Fehler angezeigt wurde, der aufgrund des schlechten schwachen Zeigers aufgetreten ist.

Beispiel # 02:

In diesem Beispiel werden wir versuchen, ein weiteres Bad_Weak_Ptr -Programm durchzuführen, in dem wir ein Objekt mit gemeinsamem Zeigertyp erstellen und den Konstruktor und den Destruktor aufrufen. Lassen Sie uns eine detaillierte Ansicht des Codes haben, den wir ausführen werden. Nachdem wir dieselben Header -Dateien aufgenommen haben, die wir in das obige Beispiel aufgenommen haben. Wir erstellen ein Objekt „BD_PTR“ mithilfe der Struktur. Und genannt enabled_shared_from_this für das BD_PTR -Objekt, mit dem das Objekt BD_PTR, das vom gemeinsam genannten Zeiger mit dem Namen "BD_PTR" verwaltet wird, verwaltet wird.

In diesem Objekt werden wir den Konstruktor für den „BD_PTR“ und den Destruktor aufrufen. Außerdem geben wir in beiden Funktionen die Erklärung über, die auf ihrer erfolgreichen Ausführung angezeigt wird. Und erstellte auch eine Funktion für dieses Objekt "BD-PTR" mit dem Namen "getBdptr", mit dem die Shared_Ptr zurückgegeben wird, die das Eigentum von "This" teilen wird. Die Methode "Shared_From_this ()" "wird verwendet, um dem Objekt, das der freigegebene Zeiger verwaltet. Gehen Sie nun in unsere Hauptfunktion ein, in der wir die Anweisung von Try angerufen haben, in der wir eine Variable mit dem Namen „F“ des Objekts „BD_PTR“ deklarierten, dem wir einen Speicherhaufen mit einem Keyword „Neu“ zugewiesen haben.

Wir haben auch einen weiteren gemeinsamen Zeiger vom Typ "bd_ptr" mit dem Namen "SP" erstellt, dem wir eine getbdptr () -Methode zugewiesen haben. Mit dem Bediener "->" haben wir auf das Element der Struktur für die Variable "F" zugegriffen. An die Catch -Methode haben wir einen konstanten Typ Bad_weak_ptr mit dem Namen "BadWeakptr" übergeben, was bedeutet, dass bei der Ausnahme von Bad_Weak_Ptr den inneren Code angezeigt wird, den wir in den lockigen Klammern geschrieben haben, in denen der Name der Ausnahme auftritt, die auftritt Und am Ende beenden wir den Code mit -1.

#enthalten
#enthalten
Struktur BD_PTR: public std :: enable_shared_from_this
bd_ptr () std :: cout << "bad pointer constructor\n";
~ bd_ptr () std :: cout << "bad pointer destructor\n";
std :: shared_ptr getbdptr () return shared_from_this ();
;
int main ()

versuchen

bd_ptr *f = new Bd_ptr;
STD :: SHARED_PTR SP = F-> GETBDPTR ();

catch (const std :: bad_weak_ptr & badWeakptr)

std :: Cout << badweakptr.what();
exit (-1);

Rückkehr 0;

Im folgenden Snippet haben wir die Erstellungsbotschaft des Konstruktors erfolgreich ausgeführt, was bedeutet, dass unser Konstruktor erfolgreich erstellt wird. Aber der Destruktor wird nicht ausgeführt, weil wir eine Ausnahme für den schlechten schwachen Zeiger gemacht haben. Daher wurde der innere Code angezeigt, den wir in der Catch -Funktion geschrieben haben, in der die auftretende Art von Fehler angezeigt wurde.

Abschluss

In diesem Handbuch haben wir die Ausnahme untersucht, die bad_weak_ptr ist, mit der die Ausnahme ausgelöst wird, und den zum Zeitpunkt der Ausführung auftretenden Nachrichtentyp des Fehlers zurückgibt. Wir haben verschiedene Beispiele durchgeführt, um das Konzept dieser Ausnahme zu erklären und wie sie im Code verwendet wird. Wir haben unser Bestes versucht, die Arbeit des bad_weak_ptr zu erklären.