Comment passer deleter à make_shared?

Depuis C++11, à cause de plusieurs raisons, les développeurs ont tendance à utiliser de pointeur intelligent classes pour la dynamique de durée de vie des objets. Et avec les nouvelles smart pointeur de classes, de normes, de même vous suggérons de ne pas utiliser des opérateurs comme new lieu de cela, ils suggèrent d'utiliser make_shared ou make_unique afin d'éviter certaines erreurs.

Si vous voulez utiliser un pointeur intelligent de la classe, comme shared_ptr, nous pouvons construire un, comme,

shared_ptr<int> p(new int(12));

Aussi nous aimerions passer une coutume deleter de pointeur intelligent classes,

shared_ptr<int> p(new int(12), deleter);

D'autre part, si nous aimons utiliser make_shared d'allouer, pour ex. int, au lieu d'utiliser new et shared_ptr constructeur, comme sur la première expression ci-dessus, nous pouvons utiliser

auto ip = make_shared<int>(12);

Mais ce qui si on aime également passer une coutume deleter à make_shared, est-il une bonne façon de le faire? Semble que les compilateurs, au moins gcc, donne une erreur,

auto ip = make_shared<int>(12, deleter);
  • Écrivez votre propre make_shared() qui prend en charge ce, c'est faisable.
InformationsquelleAutor cavitsinadogru | 2015-12-12
  1. 52

    Comme d'autres l'ont dit, make_shared ne peut pas être utilisé avec un custom deleter. Mais je veux expliquer pourquoi.

    Personnalisé deleters existent parce que vous avez alloué le pointeur d'une manière spéciale, et, par conséquent, vous devez être en mesure de libérer en contrepartie d'une façon particulière. Eh bien, make_shared alloue le pointeur avec new. Les objets alloués avec new devrait être libéré avec delete. La norme deleter consciencieusement n'.

    En bref, si vous pouvez vivre avec l'allocation par défaut de comportement, vous pouvez vivre avec la valeur par défaut de libération de la mémoire comportement trop. Et si vous ne pouvez pas vivre avec l'allocation par défaut de comportement, vous devez utiliser allocate_shared, qui utilise la condition de l'allocateur à la fois à allouer et de libérer l'espace de stockage.

    Aussi, make_shared est permis (et presque certainement) d'allouer la mémoire pour T et le bloc de contrôle pour les shared_ptr au sein de la même allocation. C'est quelque chose que votre deleter ne peut pas vraiment savoir parler ou de se traiter avec. Alors que allocate_shared est capable de les gérer, depuis l'allocateur de vous fournir peut faire l'allocation et la désallocation de fonctions.

    • Upvoted, je n'ai jamais pensé à ça, mais il fait parfaitement sens. Une bonne astuce.
    • +1 mais la coutume deleters ne sont pas seulement pour le contrôle de la libération, le pointeur de la propriété par un shared_ptr n'a pas nécessairement été "attribués" à tous. Vous pouvez utiliser fclose pour fermer un FICHIER*, par exemple. À l'aide de allocate_shared vous permet de contrôler l'allocation de mémoire, mais pas l'utilisation arbitraire des ressources. Vous avez encore de construire et de détruire un objet, non pas d'obtenir une "ressource" à partir d'une fonction et de les libérer avec un autre (deleter) de la fonction. Même si lwg 2070 est résolu que toujours ne permettent pas coutume deleters à faire/allocate_shared.
    • La ligne de fond est que, parce que faire/allocate_shared ne vous permettra pas de modifier la section "obtenir une ressource" de l'étape, il ne fait pas de sens pour eux de soutien personnalisé des moyens pour "libérer la ressource" non plus. Ils sont utilisés pour de simples créer/détruire un objet utilise de shared_ptr.
    • Ou mettre une autre façon: considérons un type incomplète, X, et les fonctions get() et put(X*). Vous pouvez l'utiliser avec shared_ptr<X>(get(), &put) mais il n'y a pas moyen d'utiliser make_shared ou allocate_shared parce qu'ils dépendent l'un de sizeof(X) qui n'est pas connu.
    • Mais dans ce cas, vous créer de l'objet pointé. Donc, vous pourriez ne jamais utiliser make_shared ou allocate_shared, puisque le but premier des deux est pour eux pour créer l'objet.
    • Que devrait être la réponse 🙂 Discuter de l'allocation et allocate_shared est inutile de faire diversion. Le point est que make_shared crée l'objet, de sorte que vous devez aussi faire confiance à "décréer" il.
    • Donc, je devrais dire, "En bref, si vous pouvez vivre avec l'allocation par défaut de comportement, vous pouvez vivre avec la valeur par défaut de libération de comportement trop?" De mon point de allocate_shared est qu'il peut être utilisé dans de nombreux cas, où vous voulez une explicite deleter. Pas forcément tous, mais beaucoup.
    • Comme je l'ai dit, il n'y a plus de "décréer" de libération, il y a aussi un destructeur, mais souvent, quand vous avez besoin d'un custom deleter il ne s'agit pas nécessairement de tout destructeur, ou de toute libération.
    • "eh Bien, make_shared alloue le pointeur avec le nouveau. Les objets alloués à nouveau doit être libéré avec les supprimer. La norme deleter consciencieusement fait." Il n'y a pas de garantie de make_shared utilise new, il pourrait l'affecter, avec std::allocator (comme mon œuvre n'), ou malloc. Ou un allocateur personnalisé, ou quelque chose d'autre. Vous ne savez pas, et si votre deleter ne sais pas quoi faire. make_shared crée l'objet, en quelque sorte, alors vous devez faire confiance à décréer il.

    InformationsquelleAutor Nicol Bolas
  2. 11

    Comme de la la documentation, make_shared accepte un liste des arguments avec lesquels une instance de T sera construit.

    En outre, la documentation dit que:

    Cette fonction est généralement utilisée pour remplacer la construction std::shared_ptr(nouveau T(args...), d'un pointeur partagé à partir de la crue de pointeur retourné par un appel à nouveau.

    À cause de cela, vous pouvez en déduire que vous ne pouvez pas personnaliser la deleter.

    Pour ce faire, vous devez créer la shared_ptr pour vous-même par le droit constructeur.

    Comme exemple d'un constructeur à partir de la liste proposée, vous pouvez utiliser:

    template< class Y, class Deleter > 
shared_ptr( Y* ptr, Deleter d );

    Ainsi, le code sera quelque chose comme:

    auto ptr = std::shared_ptr(new MyClass{arg1, arg2}, myDeleter);

    Au lieu de:

    auto ptr = std::make_shared<MyClass>(arg1, arg2);
    InformationsquelleAutor skypjack
  3. 4

    Vous ne pouvez pas. make_shared<T> transmet les arguments fournis par le constructeur de type T. Il est utilisé pour le cas simple où vous souhaitez que la valeur par défaut deleter.

    InformationsquelleAutor KyleKnoepfel
  4. 3

    Il n'est pas précisé comment make_shared obtient la mémoire de l'objet (il pourrait utiliser operator new ou malloc ou une sorte de allocateur) il n'est donc pas une coutume deleter pourrait savoir comment faire la bonne chose. make_shared crée l'objet, de sorte que vous devez aussi compter sur elle pour détruire l'objet correctement et faire le nettoyage requis, quelle qu'elle soit.

    Aussi nous aimerions passer une coutume deleter de pointeur intelligent classes,

    shared_ptr<int> p(new int(12), deleter);

    Je ne pense pas que c'est un très réalistes exemple. Une coutume deleter est généralement utilisé lorsque la ressource a été obtenue d'une manière spéciale. Si vous venez de créer avec new comme cela, alors pourquoi avez-vous besoin d'un custom deleter, de toute façon?

    Si vous voulez juste un peu de code à exécuter sur la destruction puis le mettre dans un destructeur! De cette façon, vous pouvez également l'utiliser avec make_shared par exemple

    struct RunSomethingOnDestruction {
  RunSomethingOnDestruction(int n) : i(n) { }
  ~RunSomethingOnDestruction() { /* something */ }
  int i;
};

auto px = std::make_shared<RunSomethingOnDestruction>(12);
std:shared_ptr<int> p(px, px->i);

    Cela vous donne un shared_ptr<int> qui est créé par make_shared (de sorte que vous obtenez la mémoire des optimisations effectuées par make_shared) qui va exécuter du code personnalisé sur la destruction.

    InformationsquelleAutor Jonathan Wakely
  5. 0

    Si vous utilisez un personnalisé deleter vous ne pouvez pas utiliser make_unique ou make_shared fonctions lorsque vous créez un pointeur intelligent objets . Depuis que nous avons besoin de fournir à notre clientèle des deleter ces fonctions ne supporte pas cela .

    Ne pas utiliser make_unique ou make_shared si vous avez besoin d'un custom deleter ou l'adoption d'un pointeur brut d'ailleurs.

    L'idée est que si vous avez besoin d'un spécialisé façon de le supprimer de votre objet, vous avez probablement besoin spécialisés de façon à créer eux aussi .

    Disons que nous avons une classe de Test

    #include <iostream>    
using namespace std;    
class Test
{
private : 
    int data; 
    public : 
    Test() :data{0}
    {
        cout << "Test constructor (" << data << ")" << endl;
    }
    Test(int d) : data{ d }
    {
        cout << "Test constructor (" << data << ")" << endl; 
    }
    int get_data() const { return data; }
    ~Test()
    { 
        cout << "Test Destructor (" << data << ')' << endl; 
    }
};

//main function. 
int main()
{
   //It's fine if you use  make_shared and custom deleter like this
   std::shared_ptr<Test> ptr(new Test{1000},
            [](Test *ptr)
            {
                cout << "some Code that you want to execute "; 
                delete ptr;
            });
         return 0;
}

    Mais si vous utilisez make_shared fonction, vous obtiendrez une erreur de compilation,

    std::shared_ptr<Test> ptr = make_shared<Test>(1000,
            [](Test *ptr){
               cout << "some Code that you want to execute "; 
               delete ptr;
            });

    Fondamentalement make_shared fonction est un wrapper pour new et delete et si vous voulez une coutume deleter vous devez fournir vous possédez new et delete

    InformationsquelleAutor