C将键映射到对象

Question

您好，在boost或std中是否有一个容器，其中键是类型名，值是对象/实例？？？

我想要实现的是，对于每种数据类型，我都有一个对象池，当我想要构造那个对象时，我只想通过键获取。我已经有了工作代码，但如果我使用更标准的代码，我会更高兴。

目前我有这样一个代码：

            template<size_t index, size_t counter, typename T0, typename ...T>
            struct PoolBuilderInternal
            {
                typedef typename boost::mpl::insert<
                    typename PoolBuilderInternal<index - 1, counter + 1, T...>::m
                    , boost::mpl::pair<T0, std::integral_constant<size_t, counter> > >::type m;
            };

            template<size_t counter, typename T0, typename ...T>
            struct PoolBuilderInternal<1, counter, T0, T...>
            {
                typedef typename boost::mpl::map<boost::mpl::pair<T0, std::integral_constant<size_t, counter> > > m;
            };

            template<typename ...T>
            struct Pools
            {
                std::tuple<
                    boost::object_pool<T>...> m_pools;
                typedef typename PoolBuilderInternal<sizeof...(T), 0, T...>::m poolType;

                template<typename T>
                boost::object_pool<T>& GetPool()
                {
                    return std::get< boost::mpl::at<poolType, T>::type::value>(m_pools);
                }
            };

            Pools<int, std::string, int64_t> m_pools;
            m_pools.Get<int>();

编辑：我想要的是一个COMPILE-TIME映射。你可以想象一个std::元组

Answer 1

如果我对这个问题理解正确（我不确定我是否理解），那么你真正想要的是某种类型的类工厂，这种形式是众所周知的设计模式，因为它允许工厂的用户构造其构造函数未知或不受限制的对象（当涉及类层次结构时，通常是类型）。

在此基础上，我谨向您提供以下概念验证代码。请注意，我匆匆忙忙地把它拼凑起来，它可能不是最优的。我确信还有更多的可能，包括将参数传递给相关的构造函数，以便从调用站点（例如，factory[t_string]（“我的字符串”）中make_string（））和make_foo（）。如果你对这篇文章感兴趣的话，我会在有时间的时候调查一下。

好的，这是你们的班级工厂。您应该能够将其应用于任何类型，包括boost类型。按照编码，当工厂函数（例如，make_string）添加到映射中时（这可能并不理想），需要传递给相关对象的任何参数当前都已定义。这些工厂功能也可以/应该是lambdas。同样，我稍后会补充这一点。

#include <functional>
#include <unordered_map>
#include <variant>
#include <iostream>

struct Foo
{
    Foo (int x) : x (x) { }
    int x;
};

enum ObjectType { t_string, t_foo }; // ...
using all_possible_types = std::variant <std::string, Foo>;  // ...

static all_possible_types make_string (const std::string& s)
{
    std::cout << "make_string " << s << "\n";
    return all_possible_types (std::string (s));
}

static all_possible_types make_foo (int x)
{
    std::cout << "make_foo " << x << "\n";
    return all_possible_types (Foo (x));
}

// ...                                            

int main()
{
    std::unordered_map <ObjectType, std::function <all_possible_types ()>> factory;

    factory.insert ({t_string, std::bind (make_string, "Initial string value")});
    factory.insert ({t_foo, std::bind (make_foo, 42)});
    // ...

    all_possible_types variant_string = factory [t_string] ();
    std::cout << std::get <std::string> (variant_string) << "\n\n";

    all_possible_types variant_foo = factory [t_foo] ();
    std::cout << std::get <Foo> (variant_foo).x << "\n";
}

输出：

make_string Initial string value
Initial string value

make_foo 42
42

现场演示。

正如我所说，现在看起来不太像，但我以后会改进它。同时，我建议你看一下，了解一下我在这里做什么。

Answer 2

如果池中的类型是唯一的使用c 14 std::get

#include <iostream>
#include <string>
#include <tuple>

struct A
{
    int value = 17;
};

int main()
{
    auto t = std::make_tuple(1, std::string{"Foo"}, 3.14, A{});
    std::cout << "(" << std::get<int>(t) << ", "
              << std::get<std::string>(t)
              << ", " << std::get<double>(t)
              << ", " << std::get<A>(t).value << ")\n";
}