Question

我对c ++中的私有构造函数有疑问，如果构造函数是私有的，如何创建类的实例？我们应该在类中有一个getInstance（）方法吗？

Answer 1

有private构造函数的几种情况：

限制除friend以外的所有对象的对象创建;在这种情况下，所有构造函数都必须是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`
};

限制某些类型的构造函数（即复制构造函数，默认构造函数）。例如std::fstream不允许通过此类无法访问的构造函数进行复制

有一个共同的委托构造函数，它不应该暴露给外部世界：

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

对于单class不可继承的singleton patterns（如果它是可继承的，则使用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
};

澄清：对于单例，一种典型的方法是在类中使用public: static getInstance()方法，可以访问private构造函数。最终它为外部世界创造并提供对象。

    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
    };

Answer 2

私有构造函数通常与 Builder 方法一起使用，例如在 Named Constructor 习语中。

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

在这个（典型的）示例中，命名构造函数习惯用于明确地使用哪个坐标系来构建Point对象。

Answer 3

当您想要控制类的对象创建时，私有构造函数很有用。让我们试试代码

#include <iostream>
using namespace std;
class aTestClass
{
    aTestClass()//////////private constructor of this class
    {
        cout<<"Object created\n";
    }
    public:

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

aTestClass a 行导致错误，因为此行间接尝试访问此行中的私有constructor.com并运行该程序。运行绝对正常。现在问题是如何创建对象在这种情况下。让我们写另一个程序。

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

输出

Object created

所以我们创建了一个包含私有构造函数的类的对象。 Use this concept to implement singleton class 感谢

Answer 4

是的，这通常用于通过静态成员函数访问对象的Singleton pattern。

Answer 5

这取决于为什么构造函数首先是私有的（你应该问谁编写你正在编辑的类）。有时可以将构造函数设置为私有以禁止复制构造（同时允许通过其他构造函数构造）。其他时候构造函数可以被设置为私有以禁止创建类除了类的“朋友”之外（如果类是一个“助手”，这通常会被执行，只有助手类才会被类使用）被创造了）。构造函数也可以是私有的，以强制使用（通常是静态的）创建函数。

Answer 6

如果某个构造函数是私有的，则意味着除了类本身（和朋友）之外，没有人应该能够使用该构造函数创建它的实例。因此，您可以提供类似getInstance（）的静态方法来创建类的实例，或者在某个友元类/方法中创建实例。

Answer 7

C ++中的私有构造函数可用于限制常量结构的对象创建。您可以在相同范围内定义类似常量，例如enum

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

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

像MathConst::ANG_180一样访问

Answer 8

如果创建私有构造函数，则需要在类内部创建对象

#include<iostream>
//factory method
using namespace std;
class Test
{
 private:
 Test(){
 cout<<"Object created"<<endl;
}
public:
    static Test* m1(){
        Test *t = new Test();
        return t;
    }
    void m2(){
        cout<<"m2-Test"<<endl;
    }
};
int main(){
 Test *t = Test::m1();
 t->m2();
 return 0;
}

我们何时需要C ++中的私有构造函数

8 个答案: