shared-ptr
Pourquoi un faiblesse_ptr ne peut-il pas être construit à partir d'un unique_ptr?
différences shared_ptr et faibles_ptr
Dois-je utiliser shared_ptr ou unique_ptr
Différences entre unique_ptr et shared_ptr
Quand std :: faible_ptr est-il utile?
Supprimer explicitement un shared_ptr
Utilisation de pointeurs intelligents pour les membres de la classe
Alternatives de static_pointer_cast pour unique_ptr
Est-il correct de retourner null shared_ptr?
C ++ 11 unique_ptr et shared_ptr sont-ils capables de convertir leurs types respectifs?
Pourquoi shared_ptr <void> est-il légal, alors que unique_ptr <void> est mal formé?
La méthode de surcharge pour unique_ptr et shared_ptr est ambiguë avec le polymorphisme
Comment faire pointer l'objet par un pointeur partagé?
Make_shared est-il vraiment plus efficace que nouveau?
Est-ce que l'utilisation de .reset () sur std :: shared_ptr supprime toutes les instances
Comment passer deleter to make_shared?
Alors, peut-on utiliser unique_ptr en toute sécurité dans des collections STL?
std :: auto_ptr à std :: unique_ptr
Différence entre boost :: scoped_ptr <T> et std :: unique_ptr <T>
C++ - passer des références à std :: shared_ptr ou boost :: shared_ptr
Quand utiliser des destructeurs virtuels?
obtenir un ptr normal de shared_ptr?
Pointeur NULL avec boost :: shared_ptr?
Comment supprimer intentionnellement un boost :: shared_ptr?
static_cast avec boost :: shared_ptr?
Comment libérer le pointeur de boost :: shared_ptr?
Correction de la constance du pointeur intelligent C ++
Le coût du passage par shared_ptr
Quelle est votre convention pour la typedef'ing shared_ptr?
Faut-il passer un shared_ptr par référence ou par valeur?
Exemple d'utilisation de shared_ptr?
shared_ptr Assertion px! = 0 a échoué
Comment initialiser un shared_ptr qui est membre d'une classe?
Pourquoi std :: shared_ptr <void> fonctionne
Dois-je passer de l'utilisation de boost :: shared_ptr à std :: shared_ptr?
Comment peut-on abattre un std :: shared_ptr?
Dois-je transmettre un shared_ptr par référence?
Créer un boost :: shared_ptr à une variable existante
Erreur: spécificateur de type attendu avant 'ClassName'
std :: shared_ptr thread safety expliqué
Comment le std :: tr1 :: shared_ptr est-il implémenté?
Passer des pointeurs partagés comme arguments
Utilisation de deleter personnalisé avec std :: shared_ptr
shared_ptr à un tableau: doit-il être utilisé?
Passage de shared_ptr <Derived> en tant que shared_ptr <Base>
std :: shared_ptr thread safety
C++ 11 Lors de la suppression de shared_ptr, dois-je utiliser reset ou mettre à nullptr?
Différence entre `const shared_ptr <T>` et `shared_ptr <const T>`?
initialisation std :: shared_ptr: make_shared <Foo> () vs shared_ptr <T> (nouveau Foo)
Différence entre make_shared et shared_ptr normal en C++
std :: shared_ptr upcasting à la classe de base - meilleure méthode?
Vérifiez null dans std :: shared_ptr
Comment dupliquer correctement un objet étant donné son shared_ptr
Quelle est la différence entre un std :: shared_ptr vide et un null en C ++?
shared_from_this causant bad_weak_ptr
Utiliser std :: move avec std :: shared_ptr
std :: shared_ptr: reset () vs assignation
Pourquoi shared_from_this ne peut pas être utilisé dans le constructeur d'un point de vue technique?
Passage de const shared_ptr <T> & contre juste shared_ptr <T> comme paramètre
Pourquoi devrais-je std :: move an std :: shared_ptr?
Créer shared_ptr à partir de la référence
Pourquoi faire l'opérateur new private break std :: shared_ptr?
Définissez Shared_PTR avec New_pointer qui est Old_Pointer + offset
Le deleter d'un shared_ptr est-il stocké en mémoire alloué par l'allocateur personnalisé?
ld ne peut pas trouver une bibliothèque existante
Pourquoi est-il faux d'utiliser std :: auto_ptr <> avec des conteneurs standard?
Pourquoi ne puis-je pas Push_back un unique_ptr dans un vecteur?
Pourquoi auto_ptr est-il déconseillé?
Renvoyer unique_ptr à partir de fonctions
utilisation de std :: unique_ptr
Comment faible_ptr fonctionne-t-il?
Std :: unique_ptr <T> est-il tenu de connaître la définition complète de T?
make_unique et transmission parfaite
Comment passer un argument unique_ptr à un constructeur ou à une fonction?
Comment capturer un unique_ptr dans une expression lambda?
Itérer sur un conteneur de uniques_ptr
Eh bien, comment fonctionne le suppresseur personnalisé de std :: unique_ptr?
Mauvaise pratique pour retourner unique_ptr pour un pointeur brut comme la sémantique de propriété?
Comment utiliser unique_ptr pour pimpl?
Passer unique_ptr aux fonctions
std :: unique_ptr avec un type incomplet ne compilera pas
suppresseur personnalisé lambda unique_ptr <T> pour la spécialisation des tableaux
quel est l'intérêt de std :: unique_ptr :: get
Diffusion dynamique pour unique_ptr
Comment passer std :: unique_ptr autour?
Initialiser un std :: unique_ptr en passant l'adresse du pointeur
Transférer la déclaration avec unique_ptr?
supprimer unique_ptr de la file d'attente