Beispiel 1: Shared Pointer auf unterschiedliche Weise deklarieren
Im folgenden Beispiel werden drei verschiedene Möglichkeiten zum Deklarieren eines gemeinsamen Zeigers gezeigt. Im Code wurde eine Klasse mit einem Konstruktor und einer öffentlichen Methode deklariert. Der Konstruktor gibt eine Nachricht aus, wenn ein neues gemeinsam genutztes Objekt mit dem Konstruktor erstellt wird. Die Anzeige() -Methode druckt Nachrichten basierend auf dem aufrufenden Shared Pointer-Objekt. Hier wurde das erste Shared-Pointer-Objekt erstellt, ohne den Konstruktor aufzurufen. Das zweite Shared Pointer-Objekt wurde durch Aufrufen des Konstruktors erstellt. Der dritte gemeinsame Zeiger wurde durch Zuweisen des ersten gemeinsamen Zeigers erstellt. Die Anzeige() -Methode wurde dreimal unter Verwendung von drei gemeinsam genutzten Zeigerobjekten aufgerufen.
//Notwendige Bibliotheken einbeziehen
#enthalten
#enthalten
usingnamespacestd;
// Definiere die Klasse
KlasseMyClass{
öffentlich:
// Den Konstruktor deklarieren
Meine Klasse() {
Kosten<<'Der Konstruktor wird aufgerufen. ';
}
//Eine Methode zum Drucken von Text deklarieren
voidAnzeige(Saitenstr)
{
Kosten<<'Die Methode Display() wird von der '<<P<<' Zeiger. ';
}
};
intmain()
{
//Shared_ptr initialisieren, ohne den Konstruktor aufzurufen
shared_ptr p1=make_shared();
p1->Anzeige('Erste');
//Initialize shared_ptr durch Aufruf des Konstruktors
shared_ptr p2=shared_ptr(neuMyClass);
p2->Anzeige('Sekunde');
//Shared_ptr durch Zuweisung initialisieren
shared_ptr p3=p1;
p3->Anzeige('Dritter');
zurück0;
}
Ausgabe:
Die folgende Ausgabe wird angezeigt, nachdem der obige Code ausgeführt wurde. Der Konstruktor hat nur zum Zeitpunkt der zweiten Objekterstellung aufgerufen. Die Nachricht des Konstruktors wurde also nur einmal ausgegeben:
Beispiel 2: Drucken des gespeicherten Standorts des gemeinsam genutzten Zeigers
Die Funktion Shared Pointer der Funktion get() wird verwendet, um die gespeicherte Position des Shared Pointers zurückzugeben. Im folgenden Beispiel wird die Position der gespeicherten gemeinsamen Zeiger ausgegeben, die von der Klasse und der Funktion erstellt werden. Hier wurde eine Klasse mit einem Konstruktor definiert, die zum Erstellen eines gemeinsamen Zeigers verwendet wird. Eine Funktion wurde deklariert, um einen gemeinsamen Zeiger zu erstellen und die gemeinsame Zeigerposition mit der Funktion get() auszugeben. In diesem Code wurde der erste Shared Pointer unter Verwendung der Klasse erzeugt, der zweite Shared Pointer wurde unter Verwendung der Funktion erzeugt und der dritte Shared Pointer wurde durch Zuweisen des ersten Pointers erzeugt.
//Notwendige Bibliotheken einbeziehen#enthalten
#enthalten
usingnamespacestd;
// Definiere die Klasse
KlasseMyClass
{
öffentlich:
// Den Konstruktor deklarieren
Meine Klasse() {
Kosten<<'Der Konstruktor wird aufgerufen. ';
}
};
//Funktion zum Initialisieren des Zeigers definieren
voidInit_shared_ptr()
{
shared_ptr p2(neuMyClass);
Kosten<<p2.werden() <<' ';
}
intmain()
{
//Initialize shared_ptr durch Aufruf des Konstruktors
shared_ptr p1=shared_ptr(neuMyClass);
Kosten<<p1.werden() <<' ';
//Initialize shared_ptr durch Aufruf der Funktion
Init_shared_ptr();
//Shared_ptr durch Zuweisung initialisieren
shared_ptr p3=p1;
Kosten<<p3.werden() <<' ';
zurück0;
}
Ausgabe:
Die folgende ähnliche Ausgabe wird angezeigt, nachdem der obige Code ausgeführt wurde. In der Ausgabe ist der zurückgegebene Wert der Funktion get() für den ersten und dritten gemeinsamen Zeiger gleich. Der zweite gemeinsame Zeiger ist jedoch anders:
Beispiel 3: Zählen Sie die Shared Pointer-Objekte
Das folgende Beispiel zeigt eine Möglichkeit zum Zählen der Anzahl von Objekten, auf die ein gemeinsam genutzter Zeiger zeigt, nachdem der Zeiger erstellt und zerstört wurde. Im Code wurde eine Klasse mit einem Konstruktor deklariert. Der erste gemeinsame Zeiger wurde unter Verwendung der Klasse erstellt und der zweite gemeinsame Zeiger wurde unter Verwendung des ersten gemeinsamen Zeigers erstellt. Die Anzahl der Objekte, auf die beide gemeinsamen Zeiger vor und nach dem Aufruf der reset()-Funktion zeigen, wurde später ausgegeben.
//Notwendige Bibliotheken einbeziehen#enthalten
#enthalten
usingnamespacestd;
// Definiere die Klasse
KlasseMyClass{
öffentlich:
// Den Konstruktor deklarieren
Meine Klasse() {
Kosten<<'Der Konstruktor wird aufgerufen. ';
}
};
intmain()
{
//Initialisieren Sie den ersten shared_ptr, indem Sie den Konstruktor aufrufen
shared_ptr p1(neuMyClass);
//Anzeige der Anzahl der shared_ptr-Objekte durch den ersten Zeiger
Kosten<<'p1 zeigt auf '<<p1.use_count() <<' Objekt(e). ';
//Initialisieren Sie den zweiten shared_ptr mit dem ersten shared_ptr
shared_ptr p2(p1);
//Anzeige der Anzahl der shared_ptr-Objekte durch den ersten und zweiten Zeiger
Kosten<<'p2 zeigt auf '<<p2.use_count() <<' Objekt(e). ';
Kosten<<'p1 zeigt auf '<<p1.use_count() <<' Objekt(e). ';
//Entferne den Besitz des ersten Zeigers aus dem shared_ptr-Objekt
p1.zurücksetzen();
//Anzeige der Anzahl der shared_ptr-Objekte durch den zweiten Zeiger
Kosten<<'p2 zeigt auf '<<p2.use_count() <<' Objekt(e). ';
zurück0;
}
Ausgabe:
Die folgende Ausgabe wird angezeigt, nachdem der obige Code ausgeführt wurde. Der erste Hinweis, p1 , zeigt nach der Erstellung auf ein Objekt. Nachdem Sie den zweiten Zeiger erstellt haben, p2 , mit dem ersten Zeiger, p1 , zeigen beide Zeiger auf zwei Objekte, um den Zeiger gemeinsam zu nutzen. Nach dem Aufrufen der reset()-Funktion für den Zeiger, p1 , ein Objekt wurde zerstört und der Zeiger, p2 , zeigt jetzt nur auf ein Objekt.
Abschluss:
Der Zweck der Verwendung eines gemeinsamen Zeigers in C++ wurde in diesem Tutorial anhand einfacher Beispiele erläutert. Erstellen gemeinsamer Zeiger auf unterschiedliche Weise, Abrufen der gespeicherten Position des gemeinsamen Zeigers und Zählen der Anzahl von Objekten, auf die die gemeinsamen Zeiger zeigen. Ich hoffe, dass die C++-Programmierer den Shared Pointer in ihrem Code verwenden können, nachdem sie dieses Tutorial gelesen haben.