C ++ std wew WeaPtr

Die Voraussetzung für das Studium des schwachen Zeigers ist, wir sollten über die einzigartigen Zeiger und die gemeinsamen Zeiger informieren. Ein einzigartiger Zeiger hat einzigartige Besitz. Es hält die verwalteten Objekte und erlaubt niemandem, diese Objekte zu behandeln. Nehmen wir an, wir haben ein Objekt mit dem Namen „P“, das von einem einzigartigen Zeiger verwaltet wird. Dann können wir diesen Zeiger nicht kopieren. Im anderen Fall haben wir für den gemeinsamen Zeiger auch „P“, aber wir verwenden einen gemeinsamen Zeiger. Dieses Mal können Sie diesen gemeinsamen Zeiger in verschiedenen Variablen kopieren, und wir werden eine Referenzzahl verwenden, um zu zählen.

Jetzt können wir sagen, dass der einzigartige Zeiger für ein einzigartiges Eigentum ist. Der gemeinsame Zeiger ist für gemeinsame Besitz. Und der schwache Zeiger ist für Nichtbesitz. Ein schwacher Zeiger ist auch ein intelligenter Zeiger. Es wird überhaupt nicht am Besitz beteiligt. Es ist ein Hinweis auf ein Objekt, das von einem gemeinsamen Zeiger verwaltet wird. Eine Sache, die in unserem Kopf stecken bleibt, ist, dass, wenn der schwache Zeiger keinen Besitz wie einen einzigartigen oder gemeinsamen Zeiger hat, wie dieser schwache Zeiger behandelt wird? Der Zeiger hat nichts damit, er nimmt das verwaltete Objekt aus den gemeinsamen Zeigern. Sie werden verwendet, um die kreisförmige Abhängigkeit der gemeinsam genutzten zu brechen.

Syntax:

Die Syntax für die Anwendung eines schwachen Zeigers im Programm lautet wie folgt:

std :: Wew_ptr P (neuer int);

In der angegebenen Syntax ist der Typ der Datentyp, den der schwache Zeiger steuert.

Beispiel 1:

Um den schwachen Zeiger besser zu verstehen, geben wir zunächst ein Beispiel, damit es für uns einfacher ist, zu verstehen, wie er funktioniert. In diesem Beispiel erstellen wir einen schwachen Zeiger mithilfe der gemeinsam genutzten Zeiger und zählen die Anzahl der Referenzen mit dem schwachen Zeiger. Wie wir bereits diskutiert haben, hat der schwache Zeiger selbst kein Eigentum. Es nimmt den Besitz anderer Zeiger, um eine kreisförmige Abhängigkeit von Objekten zu brechen. Wenn wir nun zu unserem Code gehen, in dem wir zum ersten Mal zwei Header -Dateien enthalten - die erste Header -Datei ist die "Speicher" und die zweite Header -Datei ist die "iOstream" -. Mit dem „iOstream“ kann der Codierer die E/A -Operationen ausführen, während der „Speicher“ die Bibliothek ist, mit der der dynamische Speicher verwaltet wird.

Als nächstes gehen wir in die Hauptfunktion, wo wir einen gemeinsamen Zeiger des Ganzzahltyps definieren und den Zeiger "SHR_PTR_A" benennen. Mit dem "neuen" Operator bringen wir den Speicher auf dem Haufen für int "12" zu, der Speicher auf den Haufen bringt. Jetzt deklarieren wir einen schwachen Zeiger des Ganzzahltyps und nennen ihn als "wk_ptr", an den wir den gemeinsam genutzten Zeiger übergeben. Dies bedeutet, dass es die Referenz der Ganzzahl "12" enthält. Nachdem wir es erfolgreich deklariert haben, drucken wir die Anzahl der Zählungen, die der schwache Zeiger unter Verwendung des "Use_Count ()" aufgerufen wird, mit dem die Anzahl der gemeinsam genutzten Zeigerinstanzen zurückgegeben werden, die das aktuelle Objekt verwalten. In diesem Beispiel führen wir diesen Schritt dreimal durch, indem wir die drei gemeinsam genutzten Objekte erstellen. Am Ende des Codes geben wir die Nullwerte zurück.

#enthalten
#enthalten
int main ()

std :: Shared_ptr SHR_PTR_A (New int (12));
std :: Wew_ptr WK_PTR (SHR_PTR_A);
std :: Cout << "Total Number of weak pointers : "
<< wk_ptr.use_count() << std::endl;
std :: Shared_ptr SHR_PTR_B (SHR_PTR_A);
std :: Cout << "Total Number of weak pointers : "
<< wk_ptr.use_count() << std::endl;
std :: Shared_ptr SHR_PTR_C (SHR_PTR_A);
std :: Cout << "Total Number of weak pointers : "
<< wk_ptr.use_count() << std::endl;
return (0);

Lassen Sie uns nun die Ausgabe des Codes überprüfen, der im folgenden Snippet angezeigt wird, in dem wir die Anzahl der erstellten Referenzen drucken. Nach der Erstellung jeder Referenz drucken wir die Anzahl dafür. Für den ersten Ausgang war es eins, für den zweiten Ausgang war es 2 und für die letzte Ausgabe war es 3. Dies bedeutet, dass die insgesamt drei Referenzen mit dem schwachen Zeiger erstellt werden.

Beispiel 2:

Wir führen ein weiteres Beispiel aus, in dem wir zwei Klassen erstellen und sie mit dem schwachen Zeiger zerstören. Wenn wir auf ein Objekt zugreifen oder es jederzeit von einem intelligenten Zeiger löschen, wird ein schwacher Zeiger verwendet, um diese zu verfolgen. Es wird als vorübergehende Besitz in einen gemeinsamen Zeiger umgewandelt. Wenn wir den ursprünglichen gemeinsamen Zeiger zerstören wollen, wird die Lebensdauer für das Objekt verlängert, bis wir den temporären gemeinsamen Zeiger zerstören.

Gehen wir nun mit dem Code fort, in dem wir zuerst die Header -Dateien aufnehmen. Bevor wir in die Hauptfunktion eintauchen, deklarieren wir zwei Klassen - der erste ist der "class_a" und der zweite ist das "class_b". In der "class_a" definieren wir zunächst einen schwachen Zeiger mit dem Namen "BPTR", indem wir das "class_b" als Parameter übergeben. Dann nennen wir einen Konstruktor und einen Destruktor für "class_a". Wir wiederholen die gleichen Schritte für die "class_b", in der wir einen schwachen Zeiger definieren und eine "class_a" als Parameter übergeben. Der Konstruktor zeigt eine Meldung der Erstellung der Klasse an. Wenn die Funktion "Zerstörungen" aufgerufen wird, wird die zerstörte Meldung der Klasse angezeigt.

Danach springen wir in die Hauptfunktion, in der wir die gemeinsam genutzten Zeiger deklarieren, die „A“ und „B“ nennen, zu. Die Funktion „make_shared“ wird verwendet, um jede Art von Objekt zuzuweisen und zu erstellen, indem der Datentyp als Argument bestanden wird. Es gibt das Objekt des gemeinsam genutzten Zeigers zurück, der der Eigentümer des Objekts ist, und speichert ihn. Zuletzt indexieren wir sie unter Verwendung der "A" und "B", die wir mit den von "BPTR" und "APTR" angegebenen Speicherindex hinter den Standorten zugreifen können, die auf den Speicherindex zugreifen können. Dies bedeutet, dass wir dem schwachen Zeiger die Objekte der gemeinsam genutzten Zeiger zuweisen.

#enthalten
#enthalten
Klasse class_b;
Klasse class_a

öffentlich:
std :: Wew_ptrBPTR;
Klasse a()
std :: Cout << "class_a created sucessfully" << std::endl;

~ class_a ()
std :: Cout << "class_a destroyed sucessfully" << std::endl;

;
Klasse class_b

öffentlich:
std :: Wew_ptraptr;
Klasse b()
std :: Cout << "class_b created sucessfull" << std::endl;

~ class_b ()
std :: Cout << "class_b destroyed sucessfully" b-> aptr = a;

Im folgenden Snippet wird die Ausgabe unseres Codes angezeigt, bei dem wir überprüfen können, ob beide class_and class_b erfolgreich erstellt und zerstört werden.

Abschluss

In diesem Artikel haben wir die Verwendung schwacher Zeiger, wie sie funktionieren und den Zweck der Verwendung der schwachen Zeiger unter Verwendung mehrerer Beispiele einschließlich des Code und der Ausgabe untersucht. Schwache Zeiger spielen eine wichtige Rolle in C++. In Abstimmung mit den gemeinsamen Zeigern helfen schwache Zeiger bei der Erklärung oder Initialisierung eines optimierten Zyklus, um die Elemente zu erhalten. Sie helfen auch beim Erwerb von Ressourcen.