C ++ enabled_shared_from_this
Wenn ein Rohzeiger übergeben wird, verstößt die Beschränkung beim Übergeben der rohen und geteilten Zeiger an denselben Speicherblock und macht den gemeinsamen Zeiger unbrauchbar. Es gibt auch eine andere Methode, um die gleiche Funktionalität auszuführen, die von der Klasse enable_shared_from_this bereitgestellt wird. Diese Methode beinhaltet jedoch die dynamische Besetzung.
Es bietet die folgenden Mitgliederfunktionen:
Konstrukteur ermöglicht es uns, ein Objekt zu konstruieren.
Zerstörer Erlauben Sie uns, das Objekt zu zerstören.
Operator "="ermöglicht es uns, den Verweis auf "This" -Zeiger zurückzugeben.
Shared_from_this wird verwendet, um den gemeinsam genutzten Zeiger zurückzugeben, der den Besitz des Zeigers „*this“ teilt.
WACK_FROM_THIS Gibt den Besitz des schwachen Zeigers zurück, der das Eigentum mit dem "*This" -Zeiger teilt.
Syntax:
VorlageDas zuvor gezeigte ist die Syntax für die Basisklasse enable_shared_from_this. T bezeichnet die Art der Klasse, die in dieser Syntax definiert werden muss.
Beispiel 1:
Jetzt probieren wir ein Beispiel für die Basisklasse enable_shared_from_this aus, um die Arbeit zu überprüfen und wie sie implementiert wird. Lassen Sie uns zunächst unsere Header -Dateien einschließen. Der erste ist der „Gedächtnis“. Der zweite ist der "iOstream". Der Speicher wird verwendet, um dem Codierer die verschiedenen Operationen auszuführen, die wie die Zuweisung des Speicherhaufens aussehen. Der zweite ist „iOstream“, bei dem es verwendet wird, um die in dem Code durchgeführten Eingabe-Output-Vorgänge zu ermöglichen, um die angezeigten Daten anzuzeigen. Mit der Struktur definieren wir nun ein Objekt mit dem Namen "SHRD_CLASS" ". Wir deklarieren unsere Basisklasse "enable_shared_from_this", an die wir die "SHRD_CLASS" übergeben haben. Dies bedeutet, dass das Objekt eine Basisklasse von enable_shared_from_this ist.
Die Struktur ist der Weg, um die verschiedenen verwandten Variablen an einem Ort zu gruppieren. In unserem Fall sammeln wir die Zeigervariablen in einer Klasse, die "obj" ist. Innerhalb des Objekts rufen wir zuerst einen Konstruktor oder das Objekt "SHRD_CLASS" auf. Anschließend deklarieren wir eine Get_Class () -Funktion des gemeinsam genutzten Zeigers des Typs „Shrd_class“, in dem die Meldung „Besitz gemeinsam genutzt“ angezeigt wird, wenn die Funktion „get_class“ aufgerufen wird und die von der von der enable_shared_from_This -Klasse bereitgestellte Shared_From_This -Methode zurückgibt, mit der das Objekt erzeugt wird, um zu erzeugen, um zu erzeugen, um zu erzeugen, um zu erzeugen, um zu erzeugen, um zu erzeugen, um zu erzeugen, um zu erzeugen, um zu erzeugen, um zu erzeugen, um zu erzeugen, um zu erzeugen, um zu erzeugen, um zu erzeugen, um zu erzeugen, um zu erzeugen, um zu erzeugen, um zu erzeugen, um zu erzeugen, um zu erzeugen, um zu erzeugen, um zu erzeugen, wird können ich erzeugt werden die Fälle des gemeinsamen Zeigers.
Jetzt gehen wir zu unserer Hauptfunktion, in der wir einen gemeinsamen Zeiger des Typs "SHRD_CLASS" deklarieren, dem wir "PF1" nennen, das wir als "PF1" bezeichnen. Wir weisen den Zeiger „SHRD_CLASS“ mit dem neuen Schlüsselwort im Speicherhaufen zu. Als Nächst. Der Bediener „->“, den wir in dieser Zeile verwenden, bedeutet, dass wir auf die Mitgliedsfunktion eines Objekts zugreifen, unabhängig davon. Verwenden des Zeigers. In diesem Beispiel greifen wir auf die Methode Get_class () der Strukturklasse „OBJ“ zu, indem wir den Zeiger „PF1“ verwenden.
#enthalten#enthalten
struct shrd_class: public std :: enable_shared_from_this
SHRD_CLASS ()
std :: shared_ptrget_class ()
std :: Cout<< "ownership shared" << std::endl;
Return Shared_from_this ();
;
int main ()
STD :: SHARED_PTR PF1 (neue SHRD_CLASS);
auto pf2 = pf1-> get_class ();
Wir freuen uns nun auf unsere Ausgabe und haben die Nachricht erfolgreich angezeigt, was bedeutet, dass das „PF1“ die Instanz des Objekts „SHRD_CLASS“ ist und das Eigentum teilt. Wir können dies im Screenshot sehen, der im Folgenden angezeigt wird:
Beispiel 2:
Lassen Sie uns ein weiteres Beispiel ausführen, in dem wir zwei gemeinsame Zeiger erstellen, die ihr Eigentum teilen. Lassen Sie uns nun zu unserem folgenden Code gehen. Wir deklarieren zuerst die Header -Dateien "iOstream" und die "Speicher" -Header -Datei. Danach deklarieren wir eine Basisklasse "Enable_shared_from_This" mit dem Namen "OBJ" mit Strukturen. Jetzt bewegen wir uns zu unserer Hauptfunktion, bei der wir die gemeinsame Nutzung des Objekts zwischen zwei verschiedenen gemeinsamen Zeigern ausführen. In der Hauptfunktion deklarieren wir einen gemeinsamen Zeiger mit dem Namen "SHRD_PTR_1" und den zweiten "SHRD_PTR_2" des Typs "OBJ". In der nächsten Zeile zum Zeiger "SHRD_PTR_1" weisen wir die Methode "make_shared () zu, mit der ein Objekt vom Typ" OBJ "zugewiesen und das SHARED_PTR -Objekt zurückgegeben wird.
Als Nächst. Darin teilt das "SHRD_PTR_1" seinen Besitz mit dem "SHRD_PTR_2" mit. Danach verwenden wir die IF () -serklärung, in der wir zwei Bedingungen bestehen. Der erste “SHRD_PTR_1.OWER_BEFORE (SHRD_PTR_2) “In diesem Eigentümer.
In unserem Fall wird überprüft. Der zweite Zustand ist umgekehrt. Darin prüfen wir, ob das "SHRD_PTR_2" kleiner als oder vor dem "SHRD_PTR_1" ist oder bestellt wird. Wenn diese beiden Bedingungen nicht auftreten, bewegt sie sich in der Anweisung if () und zeigt die Meldung „SHRD_PTR_1 und„ SHRD_PTR_2 “an und teilen Sie das Eigentum. Am Ende geben wir den Nullwert zurück, was bedeutet, dass der Code ohne Fehler erfolgreich ausgeführt wird.
#enthalten#enthalten
Struktur obj: std :: enable_shared_from_this ;
int main ()
STD :: SHARED_PTR SHRD_PTR_1, SHRD_PTR_2;
SHRD_PTR_1 = STD :: make_shared ();
SHRD_PTR_2 = SHRD_PTR_1-> SHARED_FROM_THIS ();
Wenn (!SHRD_PTR_1.Eigentümer_before (SHRD_PTR_2) && !SHRD_PTR_2.Eigentümer_before (SHRD_PTR_1))
std :: Cout<< "shrd_ptr_1 and shrd_ptr_2 share ownership";
Rückkehr 0;
Wie wir in der Ausgabe des angegebenen Codes sehen können, wird die Nachricht erfolgreich angezeigt. Dies bedeutet, dass der Eigentum zwischen beiden gemeinsamen Zeigern „SHRD_PTR_1“ und der „SHRD_PTR_2“ erfolgreich mit der Basisklasse enable_shared_from_this und ihren Mitgliedsfunktionen geteilt wird.
Abschluss
In diesem Tutorial haben wir die Methoden zur Verwendung der Klasse enable_shared_from_this beschrieben und den Grund, warum sie verwendet werden und wie sie es den Benutzern leicht machen, das Eigentum an Zeigern zwischen ihnen zu teilen. Wir haben unser Bestes versucht, die Klasse enable_shared_from_this zu erklären. Wir hoffen, dass dieser Artikel für Sie nützlich ist, um ein besseres Verständnis zu bekommen.