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

我正在尝试创建一个抽象的工厂模式，其中我有两个工厂，我们称它们为工厂A和工厂B。 我将使用结构而不是类来节省一些键入。

对于某些继承类族，让我们从某个类 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 ...
}
};

根据接口中的覆盖模板成员，我无法使模板类成为虚拟的抽象类。

但是，如果我们可以假设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);