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, " "));
}

将参数包转换为向量

3 个答案: