La création de shared_ptr de pointeur brut

J'ai un pointeur vers un objet. Je tiens à le stocker dans deux récipients qui ont à la fois la propriété. Donc, je pense que je serais bon pour en faire un shared_ptr de C++0x. Comment pourrais-je convertir un pointeur brut pour un shared_pointer?

typedef unordered_map<string, shared_ptr<classA>>MAP1;
MAP1 map1;
classA* obj = new classA();
map1[ID] = how could I store obj in map1??

Grâce

InformationsquelleAutor Leslieg | 2011-01-12
  1. 39

    Vous avez besoin pour vous assurer de ne pas initialiser les shared_ptr objets avec le même pointeur brut, ou il sera supprimé à deux reprises. Une meilleure (mais tout de même mauvaise) façon de le faire:

    classA* raw_ptr = new classA;
shared_ptr<classA> my_ptr(raw_ptr);

//or shared_ptr<classA> my_ptr = raw_ptr;

//...

shared_ptr<classA> other_ptr(my_ptr);
//or shared_ptr<classA> other_ptr = my_ptr;
//WRONG: shared_ptr<classA> other_ptr(raw_ptr);
//ALSO WRONG: shared_ptr<classA> other_ptr = raw_ptr;

    AVERTISSEMENT: le code ci-dessus montre une mauvaise pratique! raw_ptr ne devraient tout simplement pas exister en tant que variable. Si vous directement initialiser les pointeurs intelligents avec le résultat de new, vous réduisez votre risque de accidentellement de l'initialisation d'autres pointeurs intelligents de manière incorrecte. Ce que vous devez faire est:

    shared_ptr<classA> my_ptr(new classA);

shared_ptr<classA> other_ptr(my_ptr);

    Ce qui est bien c'est que le code est plus concis que bien.

    MODIFIER

    Je devrais probablement des précisions sur la façon dont il fonctionne avec une carte. Si vous aviez un pointeur brut et deux cartes, vous pourriez faire quelque chose de semblable à ce que j'ai montré ci-dessus.

    unordered_map<string, shared_ptr<classA> > my_map;
unordered_map<string, shared_ptr<classA> > that_guys_map;

shared_ptr<classA> my_ptr(new classA);

my_map.insert(make_pair("oi", my_ptr));
that_guys_map.insert(make_pair("oi", my_ptr));
//or my_map["oi"].reset(my_ptr);
//or my_map["oi"] = my_ptr;
//so many choices!
    • Ne pas exposer le pointeur brut dans une variable. En faisant cela, vous donner un responsable plus facile une occasion de vis et de mettre le pointeur BRUT dans un autre pointeur partagé. Utilisez simplement my_ptr(new ClassA()); de Cette façon, un responsable est de faire du travail supplémentaire pour visser les choses.
    • York je viens de l'édition d'inclure un point à ce sujet; je vais ajouter un plus explicite note. Mais vous avez raison. 🙂
    • // or shared_ptr<classA> my_ptr = raw_ptr; est mal dans std::shared_ptr, car il doit être explicite comme // or shared_ptr<classA> my_ptr(raw_ptr);.
    • En fait, la meilleure pratique est de make_shared<>, et d'éviter de nouveaux entièrement. Je ne me souviens pas la raison profonde, quelque chose à faire avec si la nouvelle jette, je pense que c'était dans un Sean Parent parler.
    InformationsquelleAutor Dawson
  2. 6

    Vous pouvez utiliser une variété de façons, mais le reset() serait bon:

    map1[ID].reset(obj);

    Et pour résoudre le problème d'avoir deux cartes se réfèrent à la même shared_ptr, nous pouvons avoir:

    map2[ID] = map1[ID];

    Remarque que le truc en général pour éviter une double supprimer est d'essayer d'éviter les pointeurs à tous.
    Donc à éviter:

    classA* obj = new classA();
map1[ID].reset(obj);

    mais au lieu de mettre le nouveau segment de l'objet directement dans un shared_ptr.

    • c'est pas mal pratique en soi, c'est c-pratique!
    InformationsquelleAutor Keith