什么时候我们需要C+；中的私有构造函数+；？ 我有一个关于C++中的私有构造函数的问题。如果构造函数是私有的，如何创建该类的实例

类中是否应该有一个getInstance（）方法？

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

有几个使用

私有
构造函数的场景：

限制所有对象的创建，但
朋友
s除外；在这种情况下，所有构造函数都必须是私有的

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


限制特定类型的构造函数（即复制构造函数、默认构造函数）。e、 g.
std:：fstream
不允许这种无法访问的构造函数进行复制

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

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


要有一个公共委托构造函数，它不应该暴露于外部世界：

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


当单例
类
不可继承时（如果可继承，则使用
受保护的
构造函数）


如果某个构造函数是私有的，这意味着除了类本身（和朋友）之外，没有人能够使用该构造函数创建它的实例。因此，您可以提供诸如getInstance（）之类的静态方法来创建类的实例，或者在某个友元类/方法中创建实例。
这取决于构造函数最初被设置为私有的原因（您应该询问编写您正在编辑的类的人）。有时，构造函数可能被设置为私有，以禁止复制构造（同时允许通过其他构造函数进行构造）。其他情况下，构造函数可能会被设置为私有，以禁止创建类，除非是由类的“朋友”创建（如果类是“助手”，则通常会这样做，而该“助手”只应由创建助手类的类使用）。构造函数也可能被设置为私有，以强制使用（通常是静态的）创建函数。
私有构造函数通常与生成器方法一起使用，例如在命名构造函数习惯用法中

在这个（典型的）示例中，命名构造函数习惯用法用于明确指定用于构建
点
对象的坐标系。
当您想要控制类的对象创建时，私有构造函数非常有用

让我们在代码中进行尝试：

#include <iostream>
using namespace std;

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

};

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

因此，我们创建了一个包含私有构造函数的类的对象

使用此概念实现单类类
 C++中的一个私有构造函数可用于限制常数结构的对象创建。您可以在同一范围内定义类似的常量，如enum：
struct MathConst{
    static const uint8 ANG_180 = 180;
    static const uint8 ANG_90  = 90;

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

像
MathConst:：ANG_180
一样访问它，如果创建私有构造函数，则需要在类内创建对象

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

#包括
//工厂法
使用名称空间std；
课堂测试
{
私人：
测试（）{
实际上，如果类是子类且仅从子类中使用，则它可能是受保护的静态。@larsm comment的“upvots”我不理解。它没有意义。@Alf:它不再有意义了，但在它说“它必须是公共静态”之前。如果能在帖子中为每一个案例提供示例，那就太好了。我认为在案例（3）中你希望复制构造函数是私有的，而不是公有的，对吗？是的。有一个详细的例子，这是我所知道的最常见的情况。生成器方法的另一个术语是静态工厂方法。它的用途被名称空间破坏了，你只需用名称空间替换
struct
，一切都将我一边工作，一边打扫卫生。
Object created

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

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

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