L'utilisation unique de la propriété et pointeur brut autrement?

Je suis C++11-ing un peu de code. J'ai

class X { /* */ };

class A {
    std::vector<X*> va_x;
};

class B {
    std::vector<X*> vb_x;
    std::vector<A> vb_a;
};

Le X*s de "va_x" à l'intérieur de ma classe que d'Un point pour les objets qui sont également pointé par X*s de "vb_x" à l'intérieur de ma classe B.

Maintenant je voudrais utiliser des pointeurs intelligents. Pour moi, il semble clair que la classe B est la propriété des objets pointés par le X* (en particulier parce que mon instances appartiennent à B)

Donc je devrais utiliser un unique_ptr de X à l'intérieur B:

class B {
    std::vector<unique_ptr<X>> vb_x;
    std::vector<A> vb_a;
};

Ma question est, que dois-je faire pour la classe A? Devrais-je continuer à raw pointeurs? Ce faisant, dans mes tests unitaires, je dois avouer qu'elle mène pour certaines choses (omi), par exemple (ne vous inquiétez pas à propos de l'encapsulation, qui n'est pas le point):

unique_ptr<X> x(new X());
A a;
a.va_x.push_back(&(*x)); //awkward, but what else can I do?

A.vb_a.push_back(a); //ok
B.vb_x.push_back(move(x)); //ok
Pour les questions d'avenir sur le C++11, veuillez marquer avec C++ aswell. 🙂
N'avez-vous pas demander à un quasi identiques, question déjà?
Bien le précédent est également sur unique_ptr, mais ce n'est pas la même chose je pense
Vous devriez probablement juste de ne pas stocker des premières pointeurs dans le vecteur en premier lieu! Pourquoi ne pas mettre le unique les pointeurs dans le vecteur?
Dans ce cas, le magasin de référence de l'encapsulation en A, et de construire votre code, de sorte qu'il est obligatoire pour les B objet d'exister en premier.

OriginalL'auteur Bérenger | 2012-09-23

  1. 10

    Vous pouvez utiliser x.get(), qui sera de retour le pointeur interne.

    Autres que que, oui, à l'aide de matières pointeurs pour manipuler non propriétaire des références est la voie à suivre, voir aussi cette question.

    Ok merci. Mais ce n'est pas tellement mieux de droite? Je dois donc utiliser des pointeurs de toute façon ?
    Il est rien de mal avec l'aide de matières pointeurs tant qu'ils ne possèdent pas de quoi que ce soit. Comme le nom le dit, ils devraient tout simplement le point de choses et tout est OK.
    Deviner en résolu alors. Je suis très prudent au sujet de ces nouvelles fonctionnalités, car je n'ai pas vu de code réel avec eux. Et comme je l'ai entendu dire "remplacer vos premières pointeurs intelligents" partout, j'ai commencé à penser raw pointeurs ne sont plus nécessaires (ce qui n'est pas très intelligente, je l'avoue...) Merci
    Je tiens à être en désaccord qu'il n'y a rien de mal avec le format raw des pointeurs. Raw les pointeurs sont conceptuel cauchemar, parce qu'ils n'ont pas associé à la propriété de la sémantique. Soit utiliser un unique pointeur de la propriété, ou une référence (wrapper) pour ambiently appartenant à des objets.

    OriginalL'auteur Xeo

  2. -1

    Comme Xeo dit, dans sa réponse, la solution consiste généralement à utiliser x.get().

    Il est un exemple d'un FILE qui utilise x.get() chaque fois qu'il doit être accessible:

    void file_deleter(FILE *f)
{
    fclose(f);
}

[...]

{
    std::unique_ptr<FILE, decltype(&file_deleter)>
                       f(fopen("/tmp/test.tmp", "rw"), &file_deleter);

    //read/write use f.get() as in:
    fread(buf, 1, sizeof(buf), f.get());
    fwrite(buf, 1, sizeof(buf), f.get());

    //fclose() gets called in the deleter, no need to do anything
}

    Cependant, dans votre cas, vous devez utiliser x.release().

    A a;
{
    unique_ptr<X> x(new X());
    a.va_x.push_back(&(*x)); //this is wrong
}
//here a[0] is a dangling pointer

    La &(*x) obtiendrez le pointeur brut et en faire une copie dans le a vecteur. Cependant, au moment de la unique_ptr<> est hors de portée, ce pointeur est supprimé. Ainsi, après la }, le pointeur de la a vecteur n'est pas au top (bien qu'il puisse travailler pour un peu de temps.)

    La façon correcte de transfert de la nue-pointeur est d'utiliser le release() fonction:

        a.va_x.push_back(x.release()); //this works

    Après que l'une des lignes, le pointeur est seulement dans le a vecteur. Il a été libéré de l'unique pointeur avec l'idée que l'appelant devient maintenant responsable de la gestion de cette ressource.

    REMARQUE IMPORTANTE: La push_back() peut jeter (bad_alloc) et si cela arrive, la ressource est perdu. Pour éviter ce problème (dans le cas où votre logiciel de captures de la bad_alloc et continue à fonctionner), vous devez d'abord réserver un espace dans le vecteur tel que:

        a.va_x.reserve(a.va_x.size() + 1);  //malloc() happens here
    a.va_x.push_back(x.release());      //no `bad_alloc` possible here

    De cette façon, le bad_alloc arriverait sur cette déclaration alors que la ressource est encore attaché à la unique_ptr et vous n'avez pas de fuite dans le cas d'une exception.

    Tout ce qui est dit, vous avez probablement été dans le besoin d'un shared_ptr à la place. Ceux-ci peuvent être copiés sans problème. Un unique_ptr est plus une ressource allouée une fois et puis oublié une fonction retourne ou un objet est supprimé. Lorsque les (nombreuses) des copies sont impliqués, un shared_ptr a plus de sens.

    class X
{
    typedef std::shared_ptr<X> pointer_t;
    [...]
}

class A
{
    std::vector<X::pointer_t> va_x;
}

X::pointer_t x(new X());
A a;
a.va_x.push_back(x); //much cleaner and the pointer is still managed
    "Cependant, dans votre cas, vous devez utiliser x.release()". Pas de. Qui va à l'encontre de la point de l'utilisation d'un pointeur unique, puisque je suis maintenant responsable de la suppression de l'aiguille.
    Eh bien, si vous ne le faites pas, alors vous devez vous assurer que le vecteur est hors de portée avant le unique_ptr instance. Si vous pouvez le faire dans votre code, alors vous êtes bon, en effet.

    OriginalL'auteur Alexis Wilke