Choose template based on run-time string in C++

Question

I have an attribute vector that can hold different types:

class base_attribute_vector; // no template args

template
class raw_attribute_ve         


        

Answer 1

I'd probably do something like this:

Features:

• 1 - time registration of objects by passing a named prototype

• constant time lookup at runtime

• lookup by any type which can be compared to std::string

-

#include 
#include 


struct base_attribute_vector { virtual ~base_attribute_vector() = default; };

template struct attribute_vector : base_attribute_vector {};

// copyable singleton makes handling a breeze    
struct vector_factory
{
    using ptr_type = std::unique_ptr;

    template
    vector_factory add(std::string name, T)
    {
        get_impl()._generators.emplace(std::move(name),
                                       []() -> ptr_type
                                       {
                                           return std::make_unique< attribute_vector >();
                                       });
        return *this;

    }

    template
    ptr_type create(StringLike&& s) const {
        return get_impl()._generators.at(s)();
    }

private:
    using generator_type = std::function;

    struct impl
    {
        std::unordered_map, std::equal_to<>> _generators;
    };


private:

    static impl& get_impl() {
        static impl _ {};
        return _;
    }

};



// one-time registration

static const auto factory =
vector_factory()
.add("int", int())
.add("double", double())
.add("string", std::string());


int main()
{
    auto v = factory.create("int");
    auto is = vector_factory().create("int");

    auto strs = vector_factory().create("string");


}