Quand avons-nous besoin d'un constructeur privé en C++ ?

Question

J'ai une question sur les constructeurs privés en C++. Si le constructeur est privé, comment puis-je créer une instance de la classe ?

Devrions-nous avoir une méthode getInstance() à l'intérieur de la classe ?

Answer 1

Il y a quelques scénarios pour avoir private constructeurs :

1. Restreindre la création d'objets pour tous sauf friend s ; dans ce cas, tous les constructeurs doivent être des private

   class A
   {
   private:
      A () {}
   public:
      // other accessible methods
      friend class B;
   };
   
   class B
   {
   public:
      A* Create_A () { return new A; }  // creation rights only with `B`
   };

2. Restriction de certains types de constructeurs (c'est-à-dire constructeur de copie, constructeur par défaut). par ex. std::fstream ne permet pas la copie par un constructeur inaccessible.

   class A
   {
   public:
      A();
      A(int);
   private:
      A(const A&);  // C++03: Even `friend`s can't use this
      A(const A&) = delete;  // C++11: making `private` doesn't matter
   };

3. Pour avoir un constructeur de délégué commun, qui n'est pas censé être exposé au monde extérieur :

   class A
   {
   private: 
     int x_;
     A (const int x) : x_(x) {} // common delegate; but within limits of `A`
   public:
     A (const B& b) : A(b.x_) {}
     A (const C& c) : A(c.foo()) {}
   };

4. Pour modèles singletons lorsque le singleton class n'est pas héritable (s'il l'est, utilisez un fichier de type protected constructeur)

   class Singleton
   {
   public:
      static Singleton& getInstance() {
         Singleton object; // lazy initialization or use `new` & null-check
         return object;
      }
   private:
      Singleton() {}  // make `protected` for further inheritance
      Singleton(const Singleton&);  // inaccessible
      Singleton& operator=(const Singleton&);  // inaccessible
   };

Answer 2

Un constructeur privé est généralement utilisé avec Constructeur par exemple dans le Constructeur nommé idiome.

class Point
{
public:
  static Point Polar(double, double);
  static Point Cartesian(double, double);
private:
  Point(double,double);
};

Dans cet exemple (typique), l'idiome "Named Constructor" est utilisé pour indiquer explicitement le système de coordonnées utilisé pour construire l'image de l'utilisateur. Point objet.

Answer 3

Un constructeur privé est utile lorsque vous souhaitez contrôler la création d'un objet dans une classe.

Essayons en code :

#include <iostream>
using namespace std;

class aTestClass
{
    aTestClass() ////////// Private constructor of this class
    {
        cout << "Object created\n";
    }
    public:

};

int main()
{
    aTestClass a;
    aTestClass *anObject;
}

La ligne aTestClass a provoque une erreur car cette ligne essaie indirectement d'accéder au constructeur privé. Commentez cette ligne et exécutez le programme. Il fonctionne parfaitement bien. Maintenant la question est de savoir comment créer l'objet dans un tel cas. Écrivons un autre programme.

#include <iostream>
using namespace std;

class aTestClass
{
    aTestClass() ////////// Private constructor of this class
    {
        cout << "Object created\n";
    }
    public:

    aTestClass* getAnObject() ///// A public method create an object of this class and return the address of an object of that class
    {
        return (new aTestClass);
    }
};

int main()
{
    //aTestClass a;
    aTestClass *anObject = NULL;
    anObject = anObject->getAnObject();
}

Le résultat est

Object created

Nous avons donc créé un objet de la classe contenant un constructeur privé.

Utilisez ce concept pour mettre en œuvre une classe singleton

Answer 4

Oui, c'est couramment utilisé dans le Modèle singleton où l'objet est accessible par une fonction membre statique.

Answer 5

Si un constructeur est privé, cela signifie que personne d'autre que la classe elle-même (et ses amis) ne doit être en mesure de créer des instances de cette classe en utilisant ce constructeur. Par conséquent, vous pouvez fournir des méthodes statiques comme getInstance() pour créer des instances de la classe ou créer les instances dans une classe/méthode amie.