std::vector 的可变参数模板打包参数

Question

我是模板新手，我真的不明白为什么这不起作用。我希望用这些值构造向量。

main.cpp

template <typename ...T>
void int_printf(T ...args)
{
    std::vector<T> vec = {args...};

    for(auto& v:vec)
    {
        std::cout << v << std::endl;
    }
}

int main()
{
    int_printf(1,2,3,4);

    return 0;
}

预期结果

1
2
3
4

msvc 编译器出错（已翻译）

src/main.cpp(35): error C3520: 'T': the parameter pack must be expanded in this context
src/main.cpp(37): error C3536: '<begin>$L0': can't be used before initialization
src/main.cpp(37): error C3536: '<end>$L0': can't be used before initialization
src/main.cpp(37): error C2100: invalid redirection

Answer 1

您的代码中的问题是 T 在此上下文中不是模板参数，它是模板参数包，在您的示例中将扩展为 T=[int,int,int,int]。 std::vector 期望将类型作为模板参数而不是模板参数包传递。你可以使用std::common_type解决这个问题：

#include<type_traits>

template <typename ...T>
void int_printf(T ...args)
{
    //use std::common_type to deduce common type from template
    //   parameter pack
    std::vector<typename std::common_type<T...>::type> vec = {args...};

    for(auto& v:vec)
    {
        std::cout << v << std::endl;
    }
}

您应该注意，这仅在传递给 int_printf 的参数具有通用类型时才有效。

Answer 2

另一种略显冗长的方法是添加一个初始模板参数，指定vec 的类型，如下所示：

#include <iostream>
#include <vector>

template <typename T, typename ... Args>
void int_printf(Args ... args)
{
    std::vector<T> vec = {args...};

    for (auto& v : vec)
    {
        std::cout << v << std::endl;
    }
}

int main()
{
    int_printf<int>(1,2,3,4);
    return 0;
}

如果您将不兼容类型的列表传递给int_printf，这可能会给出更清晰的错误消息。

Answer 3

当您执行std::vector<T> 时，T 不是单一类型，而是一组类型。您不能将其用于向量，因为它需要元素的单一类型。

有几种方法可以处理这个问题。首先是对向量的类型进行硬编码。这使得代码不那么通用，但对你有用，因为你的函数被称为 int_printf 而不是 anything_print

另一种选择是使用std::common_type 来获取像这样的元素的通用类型

template <typename ...T>
void int_printf(T ...args)
{
    std::vector<std::common_type_t<T...>> vec = {args...};

    for(auto& v:vec)
    {
        std::cout << v << std::endl;
    }
}

您也可以使用fold expression 并完全跳过向量

template <typename ...T>
void int_printf(T ...args)
{
    ((std::cout << args << std::endl), ...);
//  ^^                                    ^
//  |          do this part         ^  ^  |
//  |              for each parameter  |  |
//  start fold expression          end fold
}

如果您只想要无限数量的int，您也可以使用SFINAE 将包类型限制为整数，例如

template <typename ...T, std::enable_if_t<std::conjunction_v<std::is_same<T, int>...>, bool> = true>
void int_printf(T ...args)
{
    ((std::cout << args << std::endl), ...);
}

现在你不能用int以外的任何东西来调用这个函数，但它可以有你想要的任意多个。