Quels sont les avantages de boost :: noncopyable

Question

Pour empêcher la copie d'une classe, vous pouvez très facilement déclarer un constructeur / opérateur d'affectation de copie privée. Mais vous pouvez aussi hériter de boost::noncopyable .

Quels sont les avantages / inconvénients de l'utilisation de boost dans ce cas?

Answer 1

Je ne vois pas de documentation avantage:

#include <boost/noncopyable.hpp>

struct A
    : private boost::noncopyable
{
};

vs:

struct A
{
     A(const A&) = delete;
     A& operator=(const A&) = delete;
};

Lorsque vous ajoutez déplacer uniquement les types, j'ai même voir la documentation trompeuse. Les deux exemples suivants ne sont pas copiable, bien qu'ils soient mobiliers:

#include <boost/noncopyable.hpp>

struct A
    : private boost::noncopyable
{
    A(A&&) = default;
    A& operator=(A&&) = default;
};

vs:

struct A
{
    A(A&&) = default;
    A& operator=(A&&) = default;
};

En vertu de l'héritage multiple, il peut même être un espace de pénalité:

#include <boost/noncopyable.hpp>

struct A
    : private boost::noncopyable
{
};

struct B
    : public A
{
    B();
    B(const B&);
    B& operator=(const B&);
};

struct C
    : public A
{
};

struct D
    : public B,
      public C,
      private boost::noncopyable
{
};

#include <iostream>

int main()
{
    std::cout << sizeof(D) << '\n';
}

Pour moi, cela m'affiche:

3

Mais ce qui, je crois, pour avoir supérieure de la documentation:

struct A
{
    A(const A&) = delete;
    A& operator=(const A&) = delete;
};

struct B
    : public A
{
    B();
    B(const B&);
    B& operator=(const B&);
};

struct C
    : public A
{
    C(const C&) = delete;
    C& operator=(const C&) = delete;
};

struct D
    : public B,
      public C
{
    D(const D&) = delete;
    D& operator=(const D&) = delete;
};

#include <iostream>

int main()
{
    std::cout << sizeof(D) << '\n';
}

Sorties:

2

Je trouve ça beaucoup plus facile de déclarer mes opérations de copie que de raison si oui ou non je suis découlant de l' boost::non_copyable plusieurs fois et si cela va me coûter. Surtout si je ne suis pas l'auteur complète de la hiérarchie d'héritage.

Answer 2

Cela rend l'intention explicite et claire , sinon il faut voir la définition de la classe, rechercher la déclaration liée à la copie-sémantique, puis rechercher le spécificateur d'accès dans lequel elle est déclarée , afin de déterminer si la classe est non copiable ou non. Une autre façon de le découvrir en écrivant du code nécessitant la copie-sémantique activée et voir l'erreur de compilation.

Answer 3

En résumant ce que les autres ont dit:

Avantages de l' boost::noncopyable sur la copie privée méthodes:

1. Il est plus explicite et descriptif de l'intention. En utilisant des fonctions de copie est un idiome qui prend plus de place qu' noncopyable.
2. Il est moins de code / moins de frappe / moins d'encombrement / de moins en moins de place à l'erreur (le plus simple serait accidentellement en fournissant une mise en œuvre).
3. Il intègre un sens droit dans le type de métadonnées de l', semblable à un C# attribut. Vous pouvez maintenant écrire une fonction qui n'accepte que des objets qui sont noncopyable.
4. Il potentiellement intercepte les erreurs plus tôt dans le processus de construction. L'erreur sera présenté au moment de la compilation plutôt que de lien-temps, dans le cas que la classe elle-même ou des amis de la classe font l'erreur de copie.
5. (presque le même que le n ° 4) Empêche la classe elle-même ou des amis de la classe à partir de l'appel de la copie privée méthodes.

Avantages de la copie privée méthodes plus boost::noncopyable:

1. Pas de boost de dépendance

Answer 4

1. L'intention de boost :: noncopyable est plus claire.
2. Boost :: noncopyable empêche les méthodes de classes d'utiliser accidentellement le constructeur de la copie privée.
3. Moins de code avec boost :: noncopyable.

Answer 5

Je ne comprends pas pourquoi personne ne semble le mentionner, mais:

Avec noncopyable vous écrivez le nom de votre classe une seule fois.

Sans duplication par cinq : un A pour 'classe A', deux pour désactiver l'affectation et deux pour désactiver le constructeur de copie.