web-dev-qa-db-fra.com

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

J'ai une question sur le constructeur privé en c ++, si le constructeur est privé, comment créer une instance de la classe? Devrions-nous avoir une méthode getInstance () dans la classe?

c++constructorprivate
32
user707549

Il existe quelques scénarios pour avoir les constructeurs private:

  1. Restreindre la création d'objets pour tous sauf friends; dans ce cas, tous les constructeurs doivent être 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. Restreindre un certain type de constructeur (constructeur de copie, constructeur par défaut). par exemple. std::fstream n'autorise pas la copie par un constructeur aussi inaccessible

  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. For singleton patterns lorsque le singleton class n'est pas héritable (s'il est héritable, utilisez un constructeur protected)

    class A
{
public:
   A();
   A(int);
private:
   A(const A&);  // Neither others nor `friend` can use this
   // A(const A&) = delete;  // C++11 equivalent `private` doesn't matter
};

Clarification: dans le cas de singletons, une méthode typique consiste à avoir une méthode public: static getInstance() dans la classe, qui peut accéder au constructeur private. Finalement, il crée et fournit un objet au monde extérieur.

    class Singleton
    {
    public:
       static Singleton& getInstance() {
          Singleton object; // invokes the `private` constructor
          return object;
       }
    private:
       Singleton() {}  // make `protected` for further inheritance
       Singleton(const Singleton&);  // inaccessible
       Singleton& operator=(const Singleton&);  // inaccessible
    };
33
iammilind

Un constructeur privé est généralement utilisé avec les méthodes Builder , par exemple dans le constructeur Named idiom.

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

Dans cet exemple (typique), l'idiome de constructeur nommé est utilisé pour indiquer explicitement le système de coordonnées utilisé pour générer l'objet Point.

12
Matthieu M.

Private Constructor est utile lorsque vous souhaitez contrôler la création d'objet d'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 parce que cette ligne tente indirectement d'accéder au constructeur privé depuis cette ligne et d'exécuter le programme .it fonctionne parfaitement. La question est maintenant de savoir comment créer un objet. Permet d'écrire 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();
}

La sortie est

Object created

nous avons donc créé un objet de la classe contenant un constructeur privé .Use this concept to implement singleton class Merci

10
Tunvir Rahman Tusher

Oui, cela est couramment utilisé dans le modèle Singleton pattern où l'accès à l'objet est effectué via une fonction membre statique.

4
murrekatt

Cela dépend de la raison pour laquelle le constructeur a été rendu privé (vous devriez demander à celui qui a écrit la classe que vous éditez). Parfois, un constructeur peut être privé pour interdire la construction de copie (tout en autorisant la construction par un autre constructeur). D'autres fois, un constructeur peut être privé pour interdire la création de la classe, sauf par les "amis" de la classe (ceci est généralement fait si la classe est un "assistant" qui ne devrait être utilisé que par la classe pour laquelle a été créé). Un constructeur peut également être rendu privé pour forcer l'utilisation d'une fonction de création (généralement statique).

2
Michael Aaron Safyan

Si un constructeur est privé, cela signifie que personne d'autre que la classe elle-même (et ses amis) ne peut en créer des instances à l'aide de ce constructeur. Par conséquent, vous pouvez fournir des méthodes statiques telles que getInstance () pour créer des instances de la classe ou créer des instances dans une classe ou une méthode amie.

1
devil

Le constructeur privé en C++ peut être utilisé pour restreindre la création d'objet de structure constante. Et vous pouvez définir une constante similaire dans la même portée, comme enum

struct MathConst{
    static const uint8 ANG_180 = 180;
    static const uint8 ANG_90  = 90;

    private:
        MathConst(); // restricting object creation
};

accès comme MathConst::ANG_180

0
C_Raj