wake-up-neo.com

Wann brauchen wir einen privaten Konstruktor in C++?

Ich habe eine Frage zum privaten Konstruktor in c ++. Wenn der Konstruktor privat ist, wie wird eine Instanz der Klasse erstellt? Sollten wir eine getInstance () -Methode in der Klasse haben?

32
user707549

Es gibt einige Szenarien für private-Konstruktoren:

  1. Einschränkung der Objekterstellung für alle außer friends; In diesem Fall müssen alle Konstruktoren private sein.

    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. Einschränkung bestimmter Konstruktortypen (d. H. Kopierkonstruktor, Standardkonstruktor). z.B. std::fstream erlaubt das Kopieren durch einen solchen Konstruktor, auf den nicht zugegriffen werden kann

  3. Einen gemeinsamen Delegatenkonstruktor zu haben, der nicht der Außenwelt ausgesetzt sein soll:

    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. Für Singleton-Muster Wenn das Singleton class nicht vererbbar ist (wenn es vererbbar ist, verwenden Sie einen protected-Konstruktor).

    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: Bei Singletons besteht eine typische Methode darin, eine public: static getInstance()-Methode innerhalb der Klasse zu haben, die auf den private-Konstruktor zugreifen kann. Schließlich schafft und liefert es Objekt an die Außenwelt.

    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

Ein privater Konstruktor wird üblicherweise mit Builder - Methoden verwendet, beispielsweise im Named Constructor idiom.

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

In diesem (typischen) Beispiel wird das Idiom Named Constructor verwendet, um explizit festzulegen, welches Koordinatensystem zum Erstellen des Point-Objekts verwendet wird.

12
Matthieu M.

Der private Konstruktor ist nützlich, wenn Sie die Objekterstellung einer Klasse steuern möchten .. _. Versuchen wir es mit 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;
}

Die Zeile aTestClass a führt zu einem Fehler, da diese Zeile indirekt versucht, auf das private constructor.comment zuzugreifen und das Programm auszuführen. Lass uns ein anderes Programm schreiben.

#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();
}

Die Ausgabe ist

Object created

wir haben also ein Objekt der Klasse erstellt, das einen privaten Konstruktor enthältUse this concept to implement singleton class Danke

10

Ja, dies wird üblicherweise im Singleton-Muster verwendet, wenn auf das Objekt über eine statische Memberfunktion zugegriffen wird.

4
murrekatt

Es hängt davon ab, warum der Konstruktor überhaupt privat gemacht wurde (Sie sollten fragen, wer die Klasse geschrieben hat, die Sie gerade bearbeiten). Manchmal kann ein Konstruktor als privat deklariert werden, um die Erstellung von Kopien zu verbieten (während die Konstruktion durch einen anderen Konstruktor möglich ist). Zu anderen Zeitpunkten kann ein Konstruktor als privat deklariert werden, um die Erstellung der Klasse mit Ausnahme der "Freunde" der Klasse nicht zuzulassen. Dies wird normalerweise durchgeführt, wenn die Klasse ein "Helfer" ist, der nur von der Klasse (n) verwendet werden sollte, für die die Helfer-Klasse gilt erstellt wurde). Ein Konstruktor kann auch privat gemacht werden, um die Verwendung einer (normalerweise statischen) Erstellungsfunktion zu erzwingen.

Wenn ein Konstruktor privat ist, bedeutet dies, dass nur die Klasse selbst (und ihre Freunde) Instanzen davon erstellen dürfen, die diesen Konstruktor verwenden. Daher können Sie statische Methoden wie getInstance () bereitstellen, um Instanzen der Klasse oder die Instanzen in einer Freundesklasse/-methode zu erstellen.

1
devil

Der private Konstruktor in C++ kann zur Einschränkung der Objekterstellung der Konstantenstruktur verwendet werden. Und Sie können eine ähnliche Konstante in demselben Umfang wie enum definieren

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

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

zugriff wie MathConst::ANG_180

0
C_Raj