可变参数函数，在编译时接受相同类型的参数并对其进行迭代

如何解决可变参数函数，在编译时接受相同类型的参数并对其进行迭代

我正在寻找一种实现Variadic函数的方法，该函数可以在编译时接受相同类型的参数，并且应该能够 重复他们 。可变参数最后都具有相同的类型。 如下所示-

void SampleFunc(Other arguments(String may be)...,int... arg)
{
   for (const auto& val : arg)
   {
      // Each argument available here.
   }
}

然后我将如下调用此函数-

SampleFunc("String","{1,2,3,4})

最重要的是，每次调用函数时，可变参数都经过硬编码，因此我应该能够在编译时生成该可变参数。

现在我正在接受如下所示的函数参数-

void SampleFunc(std::string str,std::vector<int>& nums)

但是这增加了每次我要避免的函数构造向量的运行时成本。

---

更新：-

我忘了提到此函数在开始时还有其他参数。不好意思，对此感到抱歉。我现在更新了示例。

解决方法

如果参数在编译时是已知的，则可以在c++17中使用fold expressions做类似的事情

#include <utility> // std::forward

template <typename Type>
void doSomething(Type&& arg) /* noexcept */
{
   // Each argument available here.
   std::cout << arg << "\n";
}

template <typename... Args> 
void SampleFunc(Args&&... args) /* noexcept */
{
   (doSomething(std::forward<Args>(args)),...);
}

现在您可以像这样调用函数

SampleFunc(1,2,3,4);   

并使用doSomething可以对每个参数进行操作。

（See a Demo Online）

---

在以前的编译器中，您可以模仿the fold expression via expander trick，如下所示

template <typename Type>
void doSomething(Type&& arg) /* noexcept */
{
   // Each argument available here.
   std::cout << arg << "\n";
}

template <typename... Args> 
void SampleFunc(Args&&... args) /* noexcept */
{
   using dummy = int[];
   (void)dummy {
      0,(doSomething(std::forward<Args>(args)),0)...
   };
}

（See a Demo Online）

,

对可变参量进行迭代是最简单的部分：您标记了C ++ 17，以便可以按照JeJo的建议使用模板折叠，或其他方式（递归，初始化未使用的数组）。

更复杂的是，所有参数都是完全相同的类型。

很明显，您可以使用SFINAE来推导推导类型为同一类型，但是例如，如果您传递不同类型的参数，则为

foo(1l,2l,3l,4); // long,long,int

当一个参数可转换为其他参数的类型时，代码将无法编译。

如果您接受传递附加功能，并且您的功能是模板结构的方法，则可以从using开始，从一对类型/索引中选择类型

template <typename T,std::size_t>
using get_type = T;

您可以编写如下模板结构

template <typename...>
struct bar;

template <typename T,std::size_t ... Is>
struct bar<T,std::index_sequence<Is...>>
 {
   void operator() (std::string const & str,get_type<T,Is> const & ... ts)
    { ((std::cout << ts << ' '),...,(std::cout << '\n')); }
 };

请注意，str中operator()之后的参数都是T类型，其中T是该结构的第一个模板参数。

附加功能是

template <typename T,typename ... Ts>
void foo (std::string const & str,Ts const & ... ts)
 { bar<T,std::index_sequence_for<Ts...>>{}(str,ts...); }

您可以按以下方式致电foo()

foo<int>("string",1,4l);

观察到long值（4l）被接受是因为它被转换为int。

如果愿意，您也可以直接致电bar::operator()

bar<int,std::make_index_sequence<4u>>{}("string",10,20,30,40);

但是您必须明确第二个模板参数，以便有一些冗余。

以下是完整的编译示例

#include <string>
#include <utility>
#include <iostream>

template <typename T,std::size_t>
using get_type = T;

template <typename...>
struct bar;

template <typename T,(std::cout << '\n')); }
 };

template <typename T,ts...); }

int main ()
 {
   foo<int>("string",4l); // a long value is converted to int

   bar<int,40);
 }

,

可变参数的末尾，所有参数都具有相同的类型。

std::vector可能会产生额外分配的开销，而您可能只是使用std::initializer_list来代替（可变参数）。

void SampleFunc(std::string str,std::initializer_list<int>& nums)
{
    for (int val : nums)
    {
        // Each argument available here.
    }
}

通话类似于

SampleFunc("String",{1,4});