Question

我有一个可以包含不同类型的属性向量：

class base_attribute_vector; // no template args

template<typename T>
class raw_attribute_vector : public base_attribute_vector;

raw_attribute_vector<int> foo;
raw_attribute_vector<std::string> foo;

根据类型的运行时输入，我想创建适当的数据结构。伪代码：

std::string type("int");
raw_attribute_vector<type> foo;

显然，这失败了。一个简单但丑陋且难以维护的解决方法是运行时切换/链接，如果：

base_attribute_vector *foo;
if(type == "int") foo = new raw_attribute_vector<int>;
else if(type == "string") ...

我读到了有关仿函数的运行时多态性，但发现它在概念上很容易完成。

使这项工作最好，最干净的方法是什么？我玩boost::hana，发现虽然我可以创建从字符串到类型的映射，但查找只能在编译时完成：

auto types = 
hana::make_map(
    hana::make_pair(BOOST_HANA_STRING("int"), hana::type_c<int>),
    hana::make_pair(BOOST_HANA_STRING("string"), hana::type_c<std::string>)
);

所有可能的类型在编译时都是已知的。任何建议都非常感谢。在一个完美的解决方案中，我将在一个地方创建name-＆gt;类型映射。之后，我会像这样使用它

std::vector<base_attribute_vector*> foo;

foo.push_back(magic::make_templated<raw_attribute_vector, "int">);
foo.push_back(magic::make_templated<raw_attribute_vector, "std::string">);

foo[0]->insert(123);
foo[1]->insert("bla");

foo[0]->print();
foo[1]->print();

这种魔法不需要在编译时发生。我的目标是拥有尽可能可读的代码。

Answer 1

我使用的是std::map，其中包含字符串作为键，std::function作为值。我会将字符串与返回您的类型的函数相关联。这是一个例子：

using functionType = std::function<std::unique_ptr<base_attribute_vector>()>;
std::map<std::string, functionType> theMap;

theMap.emplace("int", []{ return new raw_attribute_vector<int>; });
theMap.emplace("float", []{ return new raw_attribute_vector<float>; });

// Using the map
auto base_vec = theMap["int"](); // base_vec is an instance of raw_attribute_vector<int>

当然，如果您只在运行时知道字符串值，则此解决方案有效。

Answer 2

enum class Type
{
    Int,
    String,
    // ...
    Unknown
};

Type TypeFromString(const std::string& s)
{
    if (s == "int") { return Type::Int; }
    if (s == "string") { return Type::String; }
    // ...
    return Type::Unknown;
}

template <template <typename> class>
struct base_of;

template <template <typename> class C>
using base_of_t = typename base_of<C>::type;

然后是通用工厂

template <template <typename> class C>
std::unique_ptr<base_of_t<C>> make_templated(const std::string& typeStr)
{
    Type type = TypeFromString(typeStr);
    static const std::map<Type, std::function<std::unique_ptr<base_of_t<C>>()>> factory{
        {Type::Int, [] { return std::make_unique<C<int>>(); } },
        {Type::String, [] { return std::make_unique<C<std::string>>(); } },
        // ...
        {Type::Unknown, [] { return nullptr; } }
    };
    return factory.at(type)();
}

每个基地都需要专业化：

template <>
struct base_of<raw_attribute_vector> {
    using type = base_attribute_vector;
};

然后

auto p = make_templated<raw_attribute_vector>(s);

Demo

Answer 3

我可能会这样做：

特点：

通过传递命名原型
运行时的常量时间查找
以任何类型查找，可与std::string

-

#include <unordered_map>
#include <string>


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

template<class Type> struct attribute_vector : base_attribute_vector {};

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

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

    }

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

private:
    using generator_type = std::function<ptr_type()>;

    struct impl
    {
        std::unordered_map<std::string, generator_type, std::hash<std::string>, 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");


}

Answer 4

你不能这样做。最好的情况是，您需要支持有限数量的类型，并使用可在编译时进行评估的if语句在它们之间切换。

Answer 5

简短回答：不，您不能指示编译器在编译时评估运行时条件。甚至没有hana。

答案很长：有一些（主要是语言无关的）模式。

我假设您的base_attribute_vector有一些virtual方法，很可能是pure，在其他语言中通常称为interface。

这意味着，根据您真实问题的复杂程度，您可能需要factory或abstract factory。

您可以在C ++中创建没有虚拟方法的工厂或抽象工厂，您可以使用hana。但问题是：增加的复杂性是否真的值得（可能是非常小的）性能提升？

（如果您想要消除每个虚拟呼叫，即使从base_attribute_vector，您也必须在切换发生的入口点之后使用该类作为模板一切）< / p>

我的意思是，您是否使用虚拟方法实现了这一点，并测量了虚拟呼叫的成本太高了？

编辑：另一个，但不同的解决方案可能是使用带有访问者的变体类型，例如eggs::variant。

使用variant，您可以为每个参数类型创建包含函数的类，apply方法将根据它的运行时类型切换要运行的函数。

类似的东西：

struct handler {
  void operator()(TypeA const&)  { ... }
  void operator()(TypeB const&)  { ... }
  // ...
};

eggs::variant< ... > v;
eggs::variants::apply(handler{}, v);

如果它们有共同的部分，您甚至可以使用模板化运算符（可能使用enable_if / sfinae）。

Answer 6

主要基于Jarod42的回答，这就是我将要使用的内容：

class base_attribute_vector {};

template<typename T>
class raw_attribute_vector : public base_attribute_vector {
public:
raw_attribute_vector() {std::cout << typeid(T).name() << std::endl; }
};

template<class base, template <typename> class impl>
base* magic(std::string type) {
    if(type == "int") return new impl<int>();
    else if(type == "float") return new impl<float>();
}

int main() {
    auto x = magic<base_attribute_vector, raw_attribute_vector>("int");
    auto y = magic<base_attribute_vector, raw_attribute_vector>("float");
}

根据C ++中的运行时字符串选择模板

6 个答案: