Question

所以我想做的就是这样。

我有一个像这样的模板结构：

template <typename T>
struct TemplateTest
{
    void test(T a)
    {
        switch (typeid(boost::any_cast<T>(a)))
        {
        case typeid(int):
            {
                std::cout << "INT";
                break;
            }
        case typeid(float):
            {
                std::cout << "FLOAT";
                break;
            }
        case typeid(double):
            {
                std::cout << "DOUBLE";
                break;
            }
        default:
            {
                std::cout << "OTHER";
                break;
            };
        }
    }
};

我想使用不同类型的结构创建一个矢量，然后仅使用for循环遍历我的所有元素，然后将所有这些元素调用此函数。

我想要的是这样的东西：

typedef boost::variant<TemplateTest<float>(), TemplateTest<double>(), TemplateTest<int>() > variant;
typedef std::vector<variant> TestVar;
TestVar d;
d.push_back(new TemplateTest<float>());
d.push_back(new TemplateTest<double>());
d.push_back(new TemplateTest<int>());
for (auto value : d)
{
    value.test(5);
}

是否有任何方法可以执行此操作，而无需在函数调用之前使用特定类型的强制类型转换？

Answer 1

如果您希望单个函数针对固定数量的类型执行不同的操作，则希望使用重载函数，而不是模板。

void test(int)
{
   std::cout << "INT";
}

如果您拥有适用于多种类型的默认设置，则可以使用模板专门化。您已经有了一个包装函数which is generally a good idea的结构模板。

template <typename T>
struct TemplateTest
{
    void test(T a)
    {
        std::cout << "OTHER";
    }
};

template<>
struct TemplateTest<int>
{
    void test(int a)
    {
        std::cout << "INT";
    }
};

如果在这种过度简化的非常特殊的情况下，所有不同的只是字符串，则可以使用变量模板：

template<typename T>
constexpr char* Typename = "DEFAULT";

template<>
constexpr char* Typename<int> = "INT";

template <typename T>
struct TemplateTest
{
    void test(T a)
    {
        std::cout << Typename<T>;
    }
};

最后一个here的实时示例。您会发现您可能希望test函数为static。

C ++模板访问具有不同类型的函数

1 个答案: