Question

我正在尝试创建一个抽象的工厂模式，我有两个工厂，我们称之为factoryA和factoryB。我将使用struct而不是class来保存一些输入。

对于某些继承类的系列，让我们从一些A类开始，

struct A
{
  // ...
};

struct derivedA1 : public A
{
  // ...
};

struct derivedA2 : public derivedA1
{
  // ...
};

现在，为了便于说明，请与其他B类做同样的事情。

struct B
{
  // ...
};

struct derivedB1 : public B
{
  // ...
};

struct derivedB2 : public derivedB1
{
  // ...
};

因此，对于这些类，我正在尝试创建工厂模式（注意，在我的工作中，我们使用自定义错误处理，我将调用error_handle_t，其实现应该无关紧要）：

struct factoryA
{
    std::map<int, std::shared_ptr<A> > myMap;

    factoryA()
    {
        // setup values to search against
        myMap[0] = std::make_shared<A>();
        myMap[1] = std::make_shared<derivedA1>();
        myMap[2] = std::make_shared<derivedA2>();

        //...room for more
    }

    error_handle_t make_object(int key, std::shared_ptr<A>& object)
    {
        object = myMap[key];
        return ...
    }
};

struct factoryB
{
    std::map<int, std::shared_ptr<B> > myMap;

    factoryB()
    {
        // setup values to search against
        myMap[0] = std::make_shared<B>();
        myMap[1] = std::make_shared<derivedB1>();
        myMap[2] = std::make_shared<derivedB2>();
        //...room for more
    }

    error_handle_t make_object(int key, std::shared_ptr<B>& object)
    {
        object = myMap[key];
        return ...
    }
};

看起来“接口”抽象类可能是一个合适的基类，但每个工厂的返回类型不同。并且A类和B类之间没有共同的基类来使这项工作“很好”，因此我不能这样做

error_handle_t make_object(int key, std::shared_ptr<base_for_A_and_B>& object) = 0;

但是上面的工厂看起来很漂亮，几乎可以参数化

template <typename T>
struct base
{
    std::map<int, std::shared_ptr<T> > myMap;

    error_handle_t make_object(int key, std::shared_ptr<T>& object)
    {
        object = myMap[key];
        return ...

    }
};

根据Override template member in Interface，我不能将模板类虚拟化为抽象类。

但是如果我们可以假设make_object的“算法”是相同的。我在网上看到，这可能是一个实用工具类，

struct factoryA : private base<A>
{
    std::map<int, std::shared_ptr<A> > myMap;

    error_handle_t make_object(int key, std::shared_ptr<A>& object)
    {
        ...
        object = myMap[key];
        return ...
    }
};

但我没有覆盖模板库，只是将它用作辅助函数。并没有真正解决我想要实现的目标。

最终目标是拥有一个抽象工厂

struct factories
{
    template <typename T>
    error_handle_t create(int key, shared_ptr<T>& object)
    {
        object = make_shared<T>()->make_object(key)
        return ...;
    }
};

而不是在没有公共基类的情况下创建相同的对象。

struct factories
{
    // Initialize in ctor which I didn't include here
    factoryA concrete_factoryA;
    factoryB concrete_factoryB;

    error_handle_t createA(int key, shared_ptr<A>& object)
    {
       object = concrete_factoryA.make_object(key);
       return ...;
    }

    error_handle_t createB(int key, shared_ptr<B>& object)
    {
       object = concrete_factoryB.make_object(key);
       return ...;
    }
};

所以我必须创建一个创建方法，因为它包含许多工厂，而不使用杠杆模板和类型推导以一些干净的方式。想法或建议？

我想要的用法：

factories l_factories;
shared_ptr<A> a_ptr;
shared_ptr<B> b_ptr;

l_factories.create(0, a_ptr);
l_factories.create(1, b_ptr);

与我的相比：

factories l_factories;
shared_ptr<A> a_ptr;
shared_ptr<B> b_ptr;

l_factories.createA(0, a_ptr);
l_factories.createB(1, b_ptr);

Answer 1

您可能需要以下内容：

template <typename T>
struct factory
{
    error_handle_t create(int key, shared_ptr<T>& object)
    {
        object = make_shared<T>()->make_object(key)
        return ...;
    }
};

template <typename ... Facts>
struct factories : Facts...
{
    using Facts::create...; // C++17, but can be done in C++11 with recursion
};

using factoryA = factory<A>;
using factoryB = factory<B>;
using MyFactory = factories<factoryA, factoryB>;

在C ++ 11中，factories将是：

template <typename ... Facts> // Main declaration
struct factories {}; // Empty case

template <typename Fact>
struct factories<Fact> : Fact{};

template <typename Fact, typename ... Facts>
struct factories<Fact, Facts...> : Fact, factories<Facts...>
{
    using Fact::create;
    using factories<Facts...>::create;
};

然后

MyFactory l_factories;
shared_ptr<A> a_ptr;
shared_ptr<B> b_ptr;

l_factories.create(0, a_ptr);
l_factories.create(1, b_ptr);

Answer 2

公平地说，我不确定你在寻找什么...这应该是一个评论，而不是一个建议的答案，但这是我知道编写格式正确的代码的唯一方法。对不起我。

这句话让我觉得你正在寻找类似的东西：

template<typename T>
struct factory<T>;

template<>
struct factory<A>
{
   std::shared_ptr<A> make_object()
   {
     // ...
   }

}; 

template<>
struct factory<B>
{
    std::shared_ptr<B> make_object()
    {
      // ...
    }
};

听起来好吗？我不能说明派生类的作用是什么。

干净的方法来使用模板基类来消除工厂类的派生类的冗余

2 个答案: