Smart Zeiger in C ++
Smart Zeiger gegen reguläre Zeiger
Das zwei Hauptproblem bei der Verwendung regulärer Zeiger ist:
A. Regelmäßiger Zeiger kann die Speicherauslastung nicht effizient verwalten.
B. Es kann das Speicherobjekt nicht freigeben, wenn es im Programm nicht verwendet wird.
C. Da der normale Zeiger den Speicher des Objekts nicht zuordnen kann, wird die Adresse des Speicherobjekts, auf das der Zeiger hinweist, nicht gefunden, wenn der Zeiger aus dem Programm entfernt wird. Infolge, Speicherleck das passiert.
Dafür verwenden wir den intelligenten Zeiger über den regulären Zeiger. Die Vorteile von intelligenten Zeigern gegenüber regulären Zeigern sind:
A. Es verwaltet den Speicher automatisch.
B. Es veröffentlichte die Erinnerung des Objekts, wenn sie im Programm nicht verwendet werden.
C. Es gibt den Gedächtnis des Objekts zu, wenn der Zeiger aus dem Geltungsbereich im Programm ausgeht.
D. Smartzinter wird in C ++ zur Zuordnung der Objekte verwendet, in den verschiedenen Arten von Datenstruktur durchquert und verschiedene Arten von Lambda -Expression für die Übergabe innerhalb der Funktion verwaltet.
e. Es macht unser Programm sehr sicher und sicher. Infolgedessen wird das Programm sehr einfach zu verstehen und wird leichter zu debuggen.
Verschiedene Arten von intelligenten Zeigern
Normalerweise gibt es in C drei Arten von intelligenten Zeigern erhältlich++. Sie sind:
A. Einzigartig
B. Geteilt
C. Schwach.
Wir werden jeden von ihnen unten diskutieren.
A. Einzigartiger Zeiger
A. Eindeutiger Zeiger hält einen Zeiger auf ein Objekt. Es gibt die Erinnerung des Objekts frei, wenn es aus dem Zielfernrohr ausgeht.
B. Eines der einzigartigen Merkmale des einzigartigen Zeigers ist, dass nur eine Kopie eines Objekts im Speicher vorhanden ist. Keine anderen Ressourcen können auf dieses bestimmte Objekt hinweisen.
C. Wenn für ein Objekt im Code viele Ressourcen verfügbar sind, tritt ein Kompilierungszeitfehler auf.
Programmierbeispiel 1:
#enthalten#enthalten
Verwenden von Namespace STD;
Klasse Square
int Seite;
öffentlich :
Quadrat (int s)
Seite = S;
int Bereich ()
return (Seite*Seite);
;
int main ()
Unique_ptr P1 (neues Quadrat (2));
Cout< area () <
Ausgang:
Erläuterung:
Hier haben wir eine Klasse namens Square erstellt. In der Klasse wird eine variable Seite deklariert und ruft den Konstruktor auf, um den Wert der Seitenvariablen zu initialisieren. Jetzt haben wir eine Funktion namens Bereich definiert, die ihren Flächenwert zurückgibt.
In der Funktion main () haben wir einen einzigartigen Zeiger namens Unique_Ptr deklariert. Jetzt haben wir einen Zeiger P1 erstellt, der das Objekt des Klassenquadrats und in seiner Klammung zeigt. Wir übergeben einen Wert 2.
Wenn wir nun den Bereich über den Zeiger P1 wie p1-> aible () drucken, zeigt er die Fläche des Quadrats 4.
B. Gemeinsamer Zeiger
A. Der gemeinsame Zeiger kann im Programm angewendet werden, wenn wir mehreren Objektressourcen einen Zeiger zuweisen möchten.
B. Der gemeinsame Zeiger ist eine Adresse, die generierte Zählzeigerin erzeugt wird, mit der eine Referenz über den Umfang einer Funktion hinausgeht und überträgt werden kann.
C. Es ist sehr nützlich in OOP (objektorientiertes Programm). Um einen Zeiger als Mitgliedsvariable zu speichern, wird gemeinsamer Zeiger verwendet.
D. Der gemeinsame Zeiger wird erst gelöscht, wenn alle Ressourcen ihre Aufgabe abgeschlossen haben.
Programmierbeispiel 2:
#enthalten#enthalten
Verwenden von Namespace STD;
Klasse Square
int Seite;
öffentlich :
Quadrat (int s)
Seite = S;
int Bereich ()
return (Seite*Seite);
;
int main ()
Shared_ptrp1 (neuer Quadrat (2));
// Einführung des gemeinsamen Zeigers;
Shared_ptrp2;
P2 = p1;
Cout
Ausgang:
Erläuterung:
Dieses Programmierbeispiel 2 ist die Fortsetzung des Programmierbeispiels 1. In der MAIN () -Funktion haben wir den gemeinsam genutzten Zeiger eingeführt. Mit dem Zeiger P1 haben wir das Objekt der quadratischen Klasse erstellt. Das gleiche Objekt wird durch den Wert p2-> Bereich () und p1-> Bereich () gezeigt (). Beide zeigen, dass die Fläche des Quadrats 4 beträgt.
C. Schwacher Zeiger
A. Schwacher Zeiger ist ein Sonderfall von Zeiger, der mit den gemeinsamen Zeigern verwendet werden kann.
B. Schwacher Zeiger verfügt.
C. Es ist nicht Teil der Referenzzählung.
D. Wir verwenden den schwachen Zeiger im Programm, wenn wir ein Objekt beobachten möchten, aber es verlangt nicht, dass es am Leben bleibt.
Programmierbeispiel 3:
#enthalten#enthalten
Verwenden von Namespace STD;
Klasse Square
int Seite;
öffentlich :
Quadrat (int s)
Seite = S;
int Bereich ()
return (Seite*Seite);
;
int main ()
Shared_ptrp1 (neuer Quadrat (2));
WACK_PTRW1;
WAWE_PTR W2 (W1);
WAWE_PTR W3 (P1);
Cout<< "w1:" << w1.use_count()<
Ausgang:
Erläuterung:
Dieses Programm -Beispiel 3 ist die Fortsetzung des Programmierbeispiels 2. Hier haben wir einen gemeinsam genutzten Zeiger namens Shared_ptr eingeführt und einen Zeiger P1 erstellt, um das Objekt der quadratischen Klasse zu verweisen. Jetzt haben wir den schwachen Zeiger Wew_ptr verwendet, der W1 und W2 verweist. Im W2 passieren wir W1. Wir haben einen weiteren schwachen Zeiger W3 erstellt, bei dem wir den Zeiger P1 übergeben.
Wenn wir jetzt alle W1 drucken.Use_Count () und W2.Use_Count () wird das Ergebnis angezeigt.
Abschluss
Wenn wir über das Konzept und die Verwendung von Smart -Zeiger im Detail diskutieren, sind wir zu dieser Schlussfolgerung gekommen, dass Smart -Zeiger in C ++ eingeführt wird, um die Nachteile des normalen Zeigers zu entfernen. Über den intelligenten Zeiger können wir verschiedene Arten von Eigentümern und Ressourcen des Objekts sehr effizient verwalten. Wir hoffen, dieser Artikel ist hilfreich. Weitere Tipps und Tutorials finden Sie in anderen Linux -Hinweisartikeln.