我们什么时候需要 C++ 中的私有构造函数？

Question

我有一个关于 C++ 中的私有构造函数的问题。如果构造函数是私有的，我如何创建该类的实例？

我们应该在类中拥有 getInstance() 方法吗？

Answer 1

有一些使用 private 构造函数的场景：

1. 限制除 friend 之外的所有人的对象创建；在这种情况下，所有构造函数都必须是私有

   <前><代码>A类
   {
   私人的：
   一个 () {}
   民众：
   // 其他可访问的方法
   朋友B级；
   };

   B级
   {
   民众：
   A* Create_A () { 返回新的 A; } // 仅具有“B”的创建权限
   };

2. 限制某些类型的构造函数（即复制构造函数、默认构造函数）。例如 std::fstream 不允许通过这种不可访问的构造函数进行复制

   <前><代码>A类
   {
   民众：
   一个（）;
   A(整数);
   私人的：
   A(const A&); // C++03: 即使是“朋友”也不能使用这个
   A(const A&) = 删除； // C++11：设置 `private` 并不重要
   };

3. 要拥有一个公共的委托构造函数，该构造函数不应暴露给外部世界：

   <前><代码>A类
   {
   私人的：
   整数x_；
   A (const int x) : x_(x) {} // 公共委托；但在“A”的范围内
   民众：
   A (const B& b) : A(b.x_) {}
   A (const C& c) : A(c.foo()) {}
   };

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

   类单例
   {
   民众：
      静态单例&获取实例（）{
         单例对象； // 延迟初始化或使用 `new` &空检查
         返回对象；
      }
   私人的：
      Singleton() {} // 为进一步继承设置“protected”
      Singleton(const Singleton&); // 无法访问
      辛格尔顿&运算符=(const Singleton&); // 无法访问
   };
   

Answer 2

私有构造函数通常与Builder方法一起使用，例如在命名构造函数习惯用法中。

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 行会导致错误，因为该行间接尝试访问私有构造函数。注释掉这一行并运行程序。它运行得非常好。现在的问题是如何在这种情况下创建对象。我们来编写另一个程序。

#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

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

使用这个概念来实现单例类

Answer 4

是的，这通常用在通过静态成员函数访问对象的单例模式中。

Answer 5

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

Answer 6

这取决于为什么构造函数首先被设为私有（您应该询问编写您正在编辑的类的人）。有时，可以将构造函数设为私有以禁止复制构造（同时允许通过其他构造函数进行构造）。其他时候，构造函数可能会被设为私有，以禁止创建该类，除非该类的“朋友”除外（如果该类是“帮助器”，则通常会这样做，该类只能由该帮助器类所在的类使用被创建）。构造函数也可以设为私有，以强制使用（通常是静态的）创建函数。

Answer 7

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

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

Answer 8

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

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

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

像 MathConst::ANG_180 一样访问它。

Answer 9

我将它与返回 std::Optional 的 friend 函数结合使用，以便安全地构造对象，同时避免异常。例如：

#include <optional>

class Object {
private:
    Object(...) { /* ... */ }

    friend std::optional<Object> make_object(...);
};

std::optional<Object> make_object(...)
{
    // ...
    if (error)
        return std::nullopt;

    // else
    return std::make_optional<Object>(...);
}

并像这样使用它：

bool f()
{
    auto opt_obj = make_object(...);
    if (!opt_obj)
        return false;

    // else
    auto obj = *std::move(opt_obj);  // API magic

    // ...

    return true;
}