将参数包转换为向量

Question

我正在尝试理解 C++ 中的可变参数模板，但我迷失在以下示例中：想象一个函数 foo(T, T, T, T) 它接受相同类型 T 的可变参数数量并将它们转换为向量。知道如何实施吗？

它应该像这样工作

foo<int>(1,2,3,4) returns std::vector<int> x{1,2,3,4}
foo<double>(0.1,0.2,0.3) returns std::vector<double> x{0.1,0.2,0.3}

Answer 1

如果

T

值在编译时已知，您可以将它们作为模板参数传递并编写类似

template<typename T, T ... Is>
void foo() {
   std::vector<T> x { { Is.. } };
   
   for( auto xx:x )
      std::cout << xx << std::endl;
}

这就是所谓的

foo<int, 2, 3, 5, 7>();

否则你必须将它们作为参数传递；类似的东西

template <typename T, typename ... ARGS>
void foo (ARGS const & ... args) {    
   std::vector<T> x { { args... } };

   for( auto xx:x ) 
      std::cout << xx << std::endl;
}

这就是所谓的

foo<int>(2, 3, 5, 7);

或者也（从第一个参数推导出类型

T

）

template <typename T, typename ... ARGS>
void foo (T const & arg0, ARGS const & ... args) {    
   std::vector<T> x { { arg0, args... } };

   for( auto xx:x ) 
      std::cout << xx << std::endl;
}

这就是所谓的

foo(2, 3, 5, 7);

--编辑--

OP 写道

它应该像这样工作

foo<int>(1,2,3,4) returns std::vector<int> x{1,2,3,4}
foo<double>(0.1,0.2,0.3) returns std::vector<double> x{0.1,0.2,0.3}

所以我想你可以简单地写

template <typename T, typename ... ARGS>
std::vector<T> foo (ARGS const & ... args)
 { return { args... }; }

Answer 2

在 foo 中，我创建了一个具有精确容量来容纳所有参数的向量，然后通过将其推到向量的后面来递归地处理每个参数，该向量被传递给名为append_to_vector 的辅助模板函数。

#include<vector>    
namespace test2
{
    template<typename TN>
    void append_to_vector(std::vector<TN>& outputvector, const TN& elem)
    {
        outputvector.push_back(elem);
    };

    template<typename T0, typename ...T1toN>
    void append_to_vector(std::vector<T0>& outputvector, const T0& elem, T1toN... elems)
    {
        outputvector.push_back(elem);
        append_to_vector(outputvector, elems...);
    };

    template<typename T, typename ...T0toN>
    auto foo(const T0toN... elems)
    {
        std::vector<T> vec;
        vec.reserve(sizeof...(elems));
        append_to_vector(vec, elems...);
        return vec;
    };
}



int main()
{
   std::vector<int> vec;
   auto vec1 = test2::foo<int>(1,2,3,4);
   auto vec2 = test2::foo<double>(0.1,0.2,0.3,0.4);
   return 0;
}

Answer 3

C++14 中的实现方式：

#include <vector>
#include <initializer_list>
#include <iterator>
#include <algorithm>
#include <iostream>
template <typename T>
std::vector<T> function(std::initializer_list<T> elements)
{
    return std::vector<T>(elements.begin(), elements.end());
}

int main()
{
    std::vector<int> elements = function<int>({1, 2, 3});
    std::copy(elements.begin(), elements.end(), std::ostream_iterator<const int>(std::cout, " "));
}