template<class...Ts>struct types_t {};
template<class...Ts>constexpr types_t<Ts...> types{};

这使我们能够使用类型包，而无需元组的开销。

template<class T>
struct tag_t { using type=T;
template<class...Ts>
constexpr decltype(auto) operator()(Ts&&...ts)const {
return T{}(std::forward<Ts>(ts)...);
}
};
template<class T>
constexpr tag_t<T> tag{};

这使我们能够将类型作为值来处理。

现在，类型标记映射是一个接受类型标记并返回另一个类型标记的函数。

template<template<class...>class Z>
struct template_tag_map {
template<class In>
constexpr decltype(auto) operator()(In in_tag)const{
return tag< Z< typename decltype(in_tag)::type > >;
}
};

这需要一个模板类型映射，并将其变成一个标记映射。

template<class R=void, class Test, class Op, class T0 >
R type_switch( Test&&, Op&& op, T0&&t0 ) {
return static_cast<R>(op(std::forward<T0>(t0)));
}
template<class R=void, class Test, class Op, class T0, class...Ts >
auto type_switch( Test&& test, Op&& op, T0&& t0, Ts&&...ts )
{
if (test(t0)) return static_cast<R>(op(std::forward<T0>(t0)));
return type_switch<R>( test, op, std::forward<Ts>(ts)... );
}

这让我们可以在一堆类型上测试条件，并在"成功"的类型上运行操作。

template<class R, class maker_map, class types>
struct named_factory_t;
template<class R, class maker_map, class...Ts>
struct named_factory_t<R, maker_map, types_t<Ts...>>
{
template<class... Args>
auto operator()( std::string_view sv, Args&&... args ) const {
return type_switch<R>(
[&sv](auto tag) { return decltype(tag)::type::name == sv; },
[&](auto tag) { return maker_map{}(tag)(std::forward<Args>(args)...); },
tag<Ts>...
);
}
};

现在我们要创建某个模板类的共享指针。

struct shared_ptr_maker {
template<class Tag>
constexpr auto operator()(Tag ttag) {
using T=typename decltype(ttag)::type;
return [](auto&&...args){ return std::make_shared<T>(decltype(args)(args)...); };
}
};

因此，这使得共享指针被赋予一种类型。

template<class Second, class First>
struct compose {
template<class...Args>
constexpr decltype(auto) operator()(Args&&...args) const {
return Second{}(First{}( std::forward<Args>(args)... ));
}
};

现在我们可以在编译时编写函数对象。

接下来连接起来。

using Foos = types_t<FooA, FooB, FooC>;
constexpr named_factory_t<std::shared_ptr<Foo>, shared_ptr_maker, Foos> make_foos;
constexpr named_factory_t<std::shared_ptr<BarInterface>, compose< shared_ptr_maker, template_tag_map<Bar> >, Foos> make_bars;

和完成。

最初的设计实际上是带有lambda的c ++ 20，而不是那些用于shared_ptr_maker等的struct。

make_foos和make_bars的运行时状态均为零。

我认为需要的是某种"编译时映射"(或列表) 所有派生的 Foo 类型，以便在定义bar_factory时， 编译器可以迭代它们，但我不知道该怎么做......

这是一个基本选项：

#include <cassert>
#include <tuple>
#include <utility>
#include "foo_and_bar_without_factories.hpp"
////////////////////////////////////////////////////////////////////////////////
template<std::size_t... indices, class LoopBody>
void loop_impl(std::index_sequence<indices...>, LoopBody&& loop_body) {
(loop_body(std::integral_constant<std::size_t, indices>{}), ...);
}
template<std::size_t N, class LoopBody>
void loop(LoopBody&& loop_body) {
loop_impl(std::make_index_sequence<N>{}, std::forward<LoopBody>(loop_body));
}
////////////////////////////////////////////////////////////////////////////////
using FooTypes = std::tuple<FooA, FooB, FooC>;// single registration
std::unique_ptr<Foo> foo_factory(const std::string& name) {
std::unique_ptr<Foo> ret{};
constexpr std::size_t foo_count = std::tuple_size<FooTypes>{};
loop<foo_count>([&] (auto i) {// `i` is an std::integral_constant
using SpecificFoo = std::tuple_element_t<i, FooTypes>;
if(name == SpecificFoo::name) {
assert(!ret && "TODO: check for unique names at compile time?");
ret = std::make_unique<SpecificFoo>();
}
});
return ret;
}
std::unique_ptr<BarInterface> bar_factory(const std::string& name) {
std::unique_ptr<BarInterface> ret{};
constexpr std::size_t foo_count = std::tuple_size<FooTypes>{};
loop<foo_count>([&] (auto i) {// `i` is an std::integral_constant
using SpecificFoo = std::tuple_element_t<i, FooTypes>;
if(name == SpecificFoo::name) {
assert(!ret && "TODO: check for unique names at compile time?");
ret = std::make_unique< Bar<SpecificFoo> >();
}
});
return ret;
}

编写如下所示的泛型工厂，允许在类站点注册：

template <typename Base>
class Factory {
public:
template <typename T>
static bool Register(const char * name) {
get_mapping()[name] = [] { return std::make_unique<T>(); };
return true;
}
static std::unique_ptr<Base> factory(const std::string & name) {
auto it = get_mapping().find(name);
if (it == get_mapping().end())
return {};
else
return it->second();
}
private:
static std::map<std::string, std::function<std::unique_ptr<Base>()>> & get_mapping() {
static std::map<std::string, std::function<std::unique_ptr<Base>()>> mapping;
return mapping;
}
};

然后像这样使用它：

struct FooA: Foo {
static constexpr char const* name = "A";
inline static const bool is_registered = Factory<Foo>::Register<FooA>(name);
inline static const bool is_registered_bar = Factory<BarInterface>::Register<Bar<FooA>>(name);
void hello() override { std::cout << "Hello " << name << std::endl; }
};

和

std::unique_ptr<Foo> foo_factory(const std::string& name) {
return Factory<Foo>::factory(name);
}

注意：无法保证该类将被注册。如果没有其他依赖项，编译器可能会决定不包含翻译单元。最好简单地将所有类注册在一个中心位置。另请注意，自注册实现依赖于内联变量 (C++17)。它不是一个强依赖，可以通过在标头中声明布尔值并在 CPP 中定义它们来摆脱它(这使得自注册更丑陋，更容易注册失败)。

编辑

1. 与其他答案相比，此答案的缺点是它在启动期间而不是在编译期间执行注册。另一方面，这使得代码更简单。

2. 上面的示例假定Bar<T>的定义移到Foo之上。如果这是不可能的，那么注册可以在 cpp 中的初始化函数中完成：

   // If possible, put at the header file and uncomment:
   // inline
   const bool barInterfaceInitialized = [] {
   Factory<Foo>::Register<FooA>(FooA::name);
   Factory<Foo>::Register<FooB>(FooB::name);
   Factory<Foo>::Register<FooC>(FooC::name);
   Factory<BarInterface>::Register<Bar<FooA>>(FooA::name);
   Factory<BarInterface>::Register<Bar<FooB>>(FooB::name);
   Factory<BarInterface>::Register<Bar<FooC>>(FooC::name);
   return true;
   }();
   

在 C++17 中，我们可以应用 fold 表达式来简化生成函数的存储过程std::make_unique<FooA>()、std::make_unique<FooB>()等在本例中到工厂类中。

为了方便起见，我们定义以下类型别名Generator，它描述了每个生成函数[](){ return std::make_unique<T>(); }的类型：

template<typename T>
using Generator = std::function<std::unique_ptr<T>(void)>;

接下来，我们定义以下相当通用的函子createFactory，它将每个工厂作为哈希映射std::unordered_map返回。 在这里，我使用逗号运算符应用折叠表达式。 例如，createFactory<BarInterface, Bar, std::tuple<FooA, FooB, FooC>>()()返回与函数bar_factory对应的哈希映射：

template<typename BaseI, template<typename> typename I, typename T>
void inserter(std::unordered_map<std::string_view, Generator<BaseI>>& map)
{
map.emplace(T::name, [](){ return std::make_unique<I<T>>(); });
}
template<typename BaseI, template<typename> class I, typename T>
struct createFactory {};
template<typename BaseI, template<typename> class I, typename... Ts>
struct createFactory<BaseI, I, std::tuple<Ts...>>
{
auto operator()()
{
std::unordered_map<std::string_view, Generator<BaseI>> map;
(inserter<BaseI, I, Ts>(map), ...);

return map;
}
};

这个函子使我们能够在一个中心位置列出FooA, FooB, FooC, ...，如下所示：

演示(我还在基类中添加了虚拟析构函数)

template<typename T>
using NonInterface = T;
// This can be written in one central place.
using FooTypes = std::tuple<FooA, FooB, FooC>;
int main()
{    
const auto foo_factory = createFactory<Foo, NonInterface, FooTypes>()();
const auto foo = foo_factory.find("A");
if(foo != foo_factory.cend()){
foo->second()->hello();
}

const auto bar_factory = createFactory<BarInterface, Bar, FooTypes>()();
const auto bar = bar_factory.find("C");
if(bar != bar_factory.cend()){
bar->second()->world();
}

return 0;
}