C++ 中带有私有构造函数的工厂模式

Question

我正在尝试实现一个由

组成的工厂模式

• 工厂类
• 具有受保护构造函数的抽象类
• 具有私有构造函数和虚拟公共的继承类 析构函数。

我想确认一下

• 除了工厂之外没有其他人不能创建任何实例
• 如果定义了新的继承类，则不需要对接口类和已定义的继承类进行任何修改。突出新的类实现并添加到工厂类中的创建方法。

我也不想为每个继承的类编写类似的代码（如每个初始化的静态工厂方法），并让未来的开发人员为工厂连接做很多工作。

即使用伪代码

class Factory;

class Interface
{
    protected:
        Interface(){/*Do something*/};
    public:
        virtual ~Interface(){/*Do something*/}
    /*I wish I could do below and it is valid for all inherited 
    classes but friendship is not inherited in C++*/
    //friend Interface* Factory::create(Type)
};

class InheritedA:public Interface
{
    private:
        InheritedA(){/*Do something*/};
    public:
        virtual ~InheritedA(){/*Do something*/}
    /*I dont want to do below two lines for every inherited class*/
    //friend Interface Factory::create(Type)
    //public: Interface* factoryInheritedA(){return new InheritedA();}
};

class InheritedB:public Interface
{
    private:
        InheritedB(){/*Do something*/};
    public:
        virtual ~InheritedA(){/*Do something*/}
};

class Factory
{
     static Interface* create(Interface type)       
     {
           switch(type)
           {
           case A:
                return new InheritedA();
           case B:
                return new InheritedB();
           default:
                //exceptions etc
           }
     }
}

int main()
{
    Interface* I = Factory::create(A/*or B*/);
    return 0;
}

上面的代码是我放出来的最接近的。欢迎提出任何建议（C++ 的专长、不同的设计……）。

Answer 1

我认为这不是一个好主意，但这里有一种方法可以做到这一点。您创建一个只能由 Factory 创建的 Tag 类型，并使所有构造函数都采用该类型的参数。

class Factory;

class Tag
{
    Tag() {}
    friend Factory;
};

class Interface 
{
public:
    Interface(Tag t) {}
    virtual ~Interface() {}
};

struct Impl1: public Interface
{
    Impl1(Tag t): Interface(t) {}
};

class Factory
{
public:
   Interface* makeInstance()
   {
       return new Impl1( Tag{} );
   }
};

void foo()
{
    Impl1 i( Tag{} );
}

您将在foo() 中收到编译器错误，因为Tag::Tag 是私有的。

Answer 2

你可以有一个模板函数：

template<typename Type>
std::unique_ptr<Interface> make_interface() {
    // exceptions etc..
}

template<>
std::unique_ptr<Interface> make_interface<InheritedA>() {
    return std::make_unique<InheritedA>();
}

template<>
std::unique_ptr<Interface> make_interface<InheritedB>() {
    return std::make_unique<InheritedB>();
}

但我真的看不出所有这些 Javaesque 样板的意义所在。更不用说您正在无缘无故地将编译时信息（类型）转换为运行时信息（通过异常）。

我会选择：

std::unique_ptr<Interface> ptr_a = std::make_unique<InheritedA>();
std::unique_ptr<Interface> ptr_b = std::make_unique<InheritedB>();

在需要时。

Answer 3

使用工厂很少是一个好习惯。我把它和 Singleton 一起算作反模式。在好的设计中，类不关心它们是如何创建的。在您的情况下，当在工厂中使用时，您如何使用自定义分配器创建您的类？在堆栈上？在共享内存中？在内存映射文件中？从缓冲区？到位？这在 Factory 中真的很难涵盖，但不要绝望 - 简单而优雅的解决方案是抛弃工厂！