wake-up-neo.com

shared-ptr

Warum kann ein weak_ptr nicht aus einem unique_ptr konstruiert werden?

shared_ptr und weak_ptr Unterschiede

Unterschiede zwischen unique_ptr und shared_ptr

Wann ist std :: weak_ptr sinnvoll?

Ein explizites Löschen eines shared_ptr

Verwenden intelligenter Zeiger für Klassenmitglieder

Alternativen von static_pointer_cast für unique_ptr

Können sich C ++ 11 unique_ptr und shared_ptr gegenseitig konvertieren?

Warum ist shared_ptr <void> legal, während unique_ptr <void> schlecht geformt ist?

Die Überladungsmethode für unique_ptr und shared_ptr ist mit Polymorphismus nicht eindeutig

Ist make_shared wirklich effizienter als neu?

Wie kann ich deler an make_shared übergeben?

Ist auto_ptr veraltet?

std :: auto_ptr zu std :: unique_ptr

C++ - Weitergabe von Referenzen an std :: shared_ptr oder boost :: shared_ptr

Wann werden virtuelle Destruktoren verwendet?

Nullzeiger mit boost :: shared_ptr?

static_cast mit boost :: shared_ptr?

Wie löse ich den Zeiger von boost :: shared_ptr?

Was ist Ihre Konvention zur Typisierung von shared_ptr?

Wo ist shared_ptr?

Sollten wir einen shared_ptr als Referenz oder als Wert übergeben?

Beispiel für die Verwendung von shared_ptr?

Warum funktioniert std :: shared_ptr <void>?

Sollte ich von boost :: shared_ptr zu std :: shared_ptr wechseln?

Wie wirft man einen std :: shared_ptr runter?

Wie rufe ich :: std :: make_shared für eine Klasse mit nur geschützten oder privaten Konstruktoren auf?

Soll ich einen shared_ptr als Referenz übergeben?

Fehler: erwarteter Typbezeichner vor 'ClassName'

std :: shared_ptr Thread-Sicherheit erklärt

Gemeinsame Zeiger als Argumente übergeben

std :: shared_ptr davon

Verwendung eines benutzerdefinierten Deleters mit std :: shared_ptr

shared_ptr für ein Array: Soll es verwendet werden?

Übergeben von shared_ptr <Abgeleitet> als shared_ptr <Basis>

std :: shared_ptr Thread-Sicherheit

C++ 11 Wenn ich shared_ptr lösche, sollte ich reset verwenden oder auf nullptr setzen?

Unterschied zwischen const shared_ptr <T> und shared_ptr <const T>?

std :: shared_ptr Initialisierung: make_shared <Foo> () vs shared_ptr <T> (neues Foo)

Unterschied in make_shared und normalem shared_ptr in C++

std :: shared_ptr Upcasting auf Basisklasse - beste Methode?

Überprüfen Sie std :: shared_ptr auf null

Was ist der Unterschied zwischen einem leeren und einem leeren std :: shared_ptr in C ++?

shared_from_this verursacht bad_weak_ptr

Verwenden von std :: move mit std :: shared_ptr

std :: shared_ptr: reset () vs. Zuweisung

Warum sollte ich std :: move und std :: shared_ptr verwenden?

Warum macht operator new private break std :: shared_ptr?

Ist es empfehlenswert, Kopien derselben freigegebenen Zeiger in verschiedenen Vektoren zu speichern?

Es kann keine vorhandene Bibliothek gefunden werden

Warum ist es falsch, std :: auto_ptr <> mit Standardcontainern zu verwenden?

Warum kann ich einen unique_ptr nicht in einen Vektor zurückschieben?

Warum wird auto_ptr veraltet?

Rückgabe von unique_ptr von Funktionen

std :: unique_ptr usage

Ist std :: unique_ptr <T> erforderlich, um die vollständige Definition von T zu kennen?

make_unique und perfekte Weiterleitung

Wie übergebe ich ein unique_ptr-Argument an einen Konstruktor oder eine Funktion?

Wie funktioniert das benutzerdefinierte Löschen von std :: unique_ptr?

std :: unique_ptr mit einem unvollständigen Typ wird nicht kompiliert

was ist der Sinn von std :: unique_ptr :: get

Dynamisches Casting für unique_ptr

Wie kann man std :: unique_ptr weitergeben?

Initialisieren eines std :: unique_ptr durch Übergeben der Adresse des Zeigers

Forward-Deklaration mit unique_ptr?

Kopieren Sie den Konstruktor für eine Klasse mit unique_ptr

Soll ich einen unique_ptr zuweisen oder zurücksetzen?

Wie deklariert man std :: unique_ptr und wozu dient es?

C++ fügt unique_ptr in die Map ein

unique_ptr für eine abgeleitete Klasse als Argument für eine Funktion, die einen unique_ptr für eine Basisklasse verwendet

Fehler: "unique_ptr" ist kein Mitglied von "std".

Wie verwende ich einen benutzerdefinierten Deleter mit einem std :: unique_ptr-Mitglied?

Wie initialisiere ich std :: unique_ptr im Konstruktor?

"Downcasting" von unique_ptr <Base> zu unique_ptr <Derived>

Richtige Methode zum Erstellen von unique_ptr, das ein zugewiesenes Array enthält

Unterschiede zwischen std :: make_unique und std :: unique_ptr mit new

error :: make_unique ist kein Mitglied von "std"

Ruft unique_ptr :: release () den Destruktor auf?

Wie weisen Sie einem Smart Pointer eine Adresse eines vorhandenen Objekts zu?

vektor von unique_ptr in C++ 11

C++ std :: unique_ptr gibt die Funktion zurück und testet auf null

Wie kann ich std :: unique_ptr an eine Funktion übergeben?

Was passiert mit unique_ptr nach std :: move ()?

Vorteile der Verwendung von std :: make_unique gegenüber dem neuen Operator

Wie prüfe ich, ob weak_ptr leer ist (nicht zugewiesen)?

Sollen Funktionsparameter zur Unterstützung der Verschiebungs-Semantik von unique_ptr, von value oder von rvalue verwendet werden?

Wie kann unique_ptr keinen Overhead haben, wenn es den Deleter speichern muss?

Warum std :: make_unique in C ++ 17 verwenden?

Warum kann ein T * im Register übergeben werden, ein unique_ptr <T> jedoch nicht?

Wann werden dynamische und statische Bibliotheken verwendet?

Ziel bestimmen ISA Erweiterungen der Binärdatei in Linux (Bibliothek oder ausführbare Datei)

Lädt Tomcat dieselbe Bibliotheksdatei zweimal in den Speicher, wenn sich diese in zwei Web-Apps befindet?

Einschränkung der Sichtbarkeit von Symbolen beim Verknüpfen von gemeinsam genutzten Bibliotheken

Linux-Fehler beim Laden von gemeinsam genutzten Bibliotheken: Gemeinsame Objektdatei kann nicht geöffnet werden: Keine solche Datei oder Verzeichnis

Dynamische gemeinsam genutzte C++ - Bibliothek unter Linux

Warum muss ich bei jedem Ausführen meiner Anwendung LD_LIBRARY_PATH mit einem Export definieren?

Warum kann Python keine freigegebenen Objekte finden, die sich in Verzeichnissen in sys.path befinden?

INSTALL_FAILED_MISSING_SHARED_LIBRARY-Fehler in Android

Wie lade ich ein freigegebenes Objekt in C++?

Wie finde ich heraus, was alle Symbole aus einem freigegebenen Objekt exportiert werden?