C++ map key to object

Question

Hi is there a container where a key is a typename and value is an object/instance in boost or std???

What I want to achieve is I have a object pool for each data type and when I want to construct that object I want to just fetch by Key. I already have working code but I would be happier if i used something more standard.

Currently I have a code like this:

            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>();

EDIT: What I want is a COMPILE-TIME map. You can imagine a std::tuple<> but some that wouldnt not be accessed by index std::get<0,1,2>... but rather by a key (?std::tuple_map)

You could use [`typeid()::hash_code()`](https://en.cppreference.com/w/cpp/language/typeid) or [`std::type_index()`](https://en.cppreference.com/w/cpp/types/type_index) to identify types. — Scheff's Cat, Jul 10 '18 at 05:35
but those are runtime values... i want to get the correct object pool at compile time. Object pools have different template arguments per type so this map has for each key a different value of different type — Martin Kosicky, Jul 10 '18 at 05:47
Use mpl::map to map a type to a storage type (one that define a static member). If you need, multiple such map, you can use a tag class. — Michael Doubez, Jul 10 '18 at 06:54
Note that it looks a bit overkill unless you need some syntactic sugar. A simple specialisation of a trait class is more readable IMHO. — Michael Doubez, Jul 10 '18 at 06:57

score 2 · Answer 1 · answered Jul 10 '18 at 07:29

If types in the pool are unique use c++ 14 std::get< T >(std::tuple(s))

#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";
}

Paul Sanders · Answer 2 · 2018-07-10T22:49:10.470

If I understand this question right (and I'm not sure I do), what you really want is some kind of class factory, and that, in various forms, is a well-known design pattern because it allows users of the factory to construct objects whose constructors (and indeed types, quite often, when a class hierarchy is involved) are unknown or off-limits to them.

On that basis, I humbly offer you the following proof-of-concept code. Please note that I threw this together in rather a hurry and it's probably not optimal. I'm sure more is possible, including passing parameters to the relevant constructors to make_string() and make_foo() from the call site (e.g. factory [t_string] ("My string"). I'll look into that when I have time, if you show any interest in this post.

OK, so here's your class factory. You should be able to apply it to any types, including boost types. As coded, any parameters that need to be passed to the object in question are currently defined when the factory function (e.g. make_string) is added to the map (which is probably not ideal). These factory functions also could / should be lambdas. Again, I'll add that in later.

#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";
}

Output:

make_string Initial string value
Initial string value

make_foo 42
42

Live demo.

As I say, this doesn't look like much now but I will improve it later. In the meantime, I suggest you take a look at it to get your head around what I'm doing here.

C++ map key to object

2 Answers2