如果构造函数在私有部分，为什么我们不能创建对象？

Question

我想知道如果构造函数在私有部分中，为什么我们不能创建对象。我知道如果我将方法设为静态，我可以使用

调用该方法

<classname> :: <methodname(...)>;

但为什么我们不能创建对象是我不明白的。

我也知道如果我的方法不是静态的，那么我也可以通过以下方式调用函数：

class A
{
     A();
     public:
        void fun1();
        void fun2();
        void fun3();
};


int main()
{
     A *obj =(A*)malloc(sizeof(A));
     //Here we can't use new A() because constructor is in private 
     //but we can use malloc with it, but it will not call the constructor
     //and hence it is harmful because object may not be in usable state.
     obj->fun1();
     obj->fun2();
     obj->fun3();
}

所以，我的问题是：为什么我们不能在构造函数是私有的时候创建一个对象？

Answer 1

因为程序无法访问它，所以这就是私有的意思。如果您将成员函数或变量声明为私有，您也将无法访问它们。在 C++ 中创建私有构造函数实际上是一种有用的技术，因为它允许您说只有特定的类才能创建该类型的实例。例如：

class A {
   A() {} // private ctor
   friend class B;
};

class B {
   public:
     A * MakeA() {
        return new A;
     }
};

只有 B 可以创建 A 对象 - 这在实现工厂模式时很有用。

Answer 2

构造函数是一个特殊的成员函数。在访问它时，它遵循与任何其他方法相同的规则。私有访问标签防止类用户调用/访问在其下声明的成员。

Answer 3

“new”操作符需要调用构造函数，所以如果构造函数是私有的，除了类A本身的成员函数之外，你不能执行代码“obj = new A”。

我猜你遇到的是一种在 Java 中经常使用的技术（是的，我知道你正在编写 C++，但原理是一样的），类的设计者想要确保此类的一个且只有一个实例将永远存在（称为“单例”）。为了实现这一点，他需要防止其他代码使用 new 创建该类的更多实例，而将构造函数设为私有是一种方法。这是一段说明该技术的 Java 代码。

public class MySingleton {

  private MySingleton() {
      // Private constructor, to prevent instantiation using "new"
      // outside of this class.
  }

  public synchronized static MySingleton getInstance() {
    static MySingleton instance = null;

    if (instance == null) {
        // I can use new here because I'm inside the class.
        instance = new MySingleton();
    }
    return instance;
  }

}

即使您不了解 Java，其语法也与 C++ 非常相似，您应该了解这段代码在做什么。关键是，在代码的其他地方获取对 MySingleton 类实例的引用的唯一方法是调用静态类成员 getInstance()。

  MySingleton obj = MySingleton.getInstance();

Answer 4

你不能实例化你的类，因为构造函数是private。 private 成员变量和函数不能在类本身之外使用。

如果您希望能够实例化您的类，您有两种选择。

选项1是制作构造函数。在绝大多数情况下，这是正确的做法。创建构造函数private 是一种有用的技术，但仅限于尝试完成特定目标时。

选项2是创建一个public static工厂方法。 You would typically do this when Option 1 isn't an option.

class A
{
     A();
     public:
    static A* Create() { return new A; }
        void fun1();
        void fun2();
        void fun3();
};


int main()
{
     A *obj = A::Create();
     //Here we can't use new A() because constructor is in private 
     //but we can use malloc with it, but it will not call the constructor
     //and hence it is harmful because object may not be in usable state.
     obj->fun1();
     obj->fun2();
     obj->fun3();
}