Vecteur de pointeurs partagés , des problèmes de mémoire après avoir franchi le vecteur

J'ai réalisé qu'après l'appel de vector.clear() qui détiennent partagé les pointeurs, les destructeurs de l'objet qui est le propre par shared_ptr n'est pas publié.

Exemple de Code peut être vu ci-dessous . Même vector.clear() être appelé, destructeur appelé après pointeur partagé va au-delà de la portée.Ma question est - ce que je dois supprimer tous les pointeurs intelligents à l'intérieur du vecteur manuellement par la réinitialisation? Est-il un moyen plus facile que vous pouvez conseiller ?

Output :   

constructor
I am here
destructor

Code:

#include <vector>
#include <iostream>
#include <memory>

using namespace std;

class A
{
public:
    A(){cout << "constructor" << endl;};
    ~A(){cout << "destructor"  << endl;};
};

int main( )
{
    shared_ptr<A> sharedptr (new A);
    std::vector<shared_ptr<A> > test;
    test.push_back(sharedptr);

    test.clear();
    cout << "I am here" << endl;
}

OriginalL'auteur Kadir Erdem Demir | 2013-10-12

  1. 32

    vous avez deux copies de shared_ptr<A> dans ce cas, l'un est le sharedptr variable et l'autre comme un élément dans le vecteur.

    faire cela à la place

    test.push_back(std::move(sharedptr));

    remarque maintenant l'original sharedptr a interne déplacé et n'est plus utilisable. L'autre chose, c'est de ne rien faire du tout, c'est parfaitement valide l'utilisation de shared_ptr et sharedptr sera de nettoyer lui-même après qu'il est hors de portée.

    Votre réponse est juste ce que je cherchais pour. Merci beaucoup.
    Je voudrais ajouter que, dans le cas indiqué dans la question, je préfère construire le vecteur en place dans le vecteur via emplace_back, afin d'éviter d'avoir un accessible variable nommée (sharedptr) dont l'utilisation serait dangereux après std::move.

    OriginalL'auteur yngccc

  2. 5

    Le problème se pose lorsque le push_back ajoute un copie de la shared_ptr pour le vecteur, en laissant l'original balançant jusqu'principal existe. Si vous ne faites pas les shared_ptr dans le champ d'application principal, le problème ne se produit pas. Juste éviter de faire de la shared_ptr dans le champ d'application principal. En faire un droit temporaire dans le push_back appel.

    Output is now:   

constructor
I am almost there
destructor
I am here

New code:

#include <vector>
#include <iostream>
#include <memory>

using namespace std;

class A
{
public:
  A(){cout << "constructor" << endl;};
  ~A(){cout << "destructor"  << endl;};
};

int main( )
{
  vector<shared_ptr<A> > test;
  test.push_back(shared_ptr<A>(new A));
  cout << "I am almost there" << endl;
  test.clear();
  cout << "I am here" << endl;
  return 0;
}
    qu'en est maked_shared ou emplace_back?

    OriginalL'auteur Fred Jackson

  3. 3

    Ici sharedptr et de l'élément dans vecteur partagent le même objet, le résultat sera en invoquant le constructeur et le destructeur qu'une seule fois.

    OriginalL'auteur daoluan