Pourquoi supprimer explicitement le constructeur au lieu de le rendre privé ?

Question

Quand/pourquoi voudrais-je supprimer explicitement mon constructeur ? En supposant que la raison est d'empêcher son utilisation, pourquoi ne pas simplement le rendre private ?

class Foo
{ 
  public: 
    Foo() = delete; 
};

Answer 1

Pourquoi pas :

//deleted constructor
class Foo
{ 
  public: 
    Foo() = delete;     
  public:
    static void foo();
};

void Foo::foo()
{
   Foo f;    //illegal
}

contre

//private constructor
class Foo
{ 
  private: 
    Foo() {}     
  public:
    static void foo();
};

void Foo::foo()
{
   Foo f;    //legal
}

Ce sont des choses fondamentalement différentes. private vous indique que seuls les membres de la classe peuvent appeler cette méthode ou accéder à cette variable (ou les amis bien sûr). Dans ce cas, il est légal pour une classe static de cette classe (ou de tout autre membre) pour appeler une méthode private constructeur d'une classe. Ceci n'est pas valable pour les constructeurs supprimés.

Echantillon aquí .

Answer 2

pourquoi supprimer explicitement le constructeur ?

Une autre raison :
J'utilise delete quand je veux m'assurer qu'une classe est appelée avec un initialisateur. Je considère qu'il s'agit d'une manière très élégante d'atteindre cet objectif sans vérification au moment de l'exécution.

Le compilateur C++ effectue cette vérification pour vous.

class Foo
{
   public:
       Foo() = delete;
       Foo(int bar) : m_bar(bar) {};
   private:
       int m_bar;
}

Ce très simplifié - assure qu'il n'y a pas d'instanciation de ce type : Foo foo;

Answer 3

J'ai rencontré des ctors par défaut déclarés comme 'supprimés' dans le code source de LLVM (dans AlignOf.h par exemple). Les modèles de classe associés sont généralement dans un espace de nom spécial appelé 'llvm::detail'. Je pense que le but est de considérer cette classe uniquement comme une classe d'aide. Ils n'ont jamais eu l'intention de les instancier ; seulement de les utiliser dans le contexte d'autres modèles de classe avec quelques astuces de métaprogrammation qui s'exécutent au moment de la compilation.

Par exemple, il existe un modèle de classe AlignmentCalcImpl qui n'est utilisé qu'à l'intérieur d'un autre modèle de classe appelé AlignOf comme paramètre pour l'opérateur sizeof(.). Cette expression peut être évaluée au moment de la compilation et il n'est pas nécessaire d'instancier le modèle -> alors pourquoi ne pas déclarer le ctor delete par défaut pour exprimer cette intention.

Mais ce n'est que ma supposition.