如何使函数接受不使用 f(...) 的任意数量的参数？

Question

一段代码值一千字：

int main()
{
    // All of the following calls return true:
    AreEqual(1, 1);
    AreEqual(1, 1, 1);
    AreEqual(1, 1, 1, 1);
    AreEqual(1, 1, 1, 1, 1);

    // All of the following calls return false:
    AreEqual(1, 2);
    AreEqual(1, 2, 1);
    AreEqual(1, 7, 3, 1);
    AreEqual(1, 4, 1, 1, 1);    
}

如何实现接受任意数量参数的函数AreEqual()？

微不足道但乏味的灵魂是通过重载：

bool AreEqual(int v1, int v2);
bool AreEqual(int v1, int v2, int v3);
bool AreEqual(int v1, int v2, int v3, int v4);
......

另一个微不足道但不可行的解决方案是：

bool AreEqual(...);

此解决方案不可行，因为调用者必须添加另一个参数（参数计数或结束标记）来指定参数的数量。

另一种方法是通过可变参数模板参数

template<class... Args>
bool AreEqual(Args... args)
{
    // What should be placed here ???
}

Answer 1

以下是如何使用模板来实现它：

#include <iostream>
#include <iomanip>

template<class T0>
bool AreEqual(T0 t0) { return true; }

template<class T0, class T1, class... Args>
bool AreEqual(T0 t0, T1 t1, Args ... args) {
  return t0 == t1 && AreEqual(t1, args...);
}


int main () {
  std::cout << std::boolalpha;

    // All of the following calls return true:
  std::cout<< AreEqual(1, 1) << "\n";
  std::cout<< AreEqual(1, 1, 1) << "\n";
  std::cout<< AreEqual(1, 1, 1, 1) << "\n";
  std::cout<< AreEqual(1, 1, 1, 1, 1) << "\n\n";

    // All of the following calls return false:
  std::cout<< AreEqual(1, 2) << "\n";
  std::cout<< AreEqual(1, 2, 1) << "\n";
  std::cout<< AreEqual(1, 7, 3, 1) << "\n";
  std::cout<< AreEqual(1, 4, 1, 1, 1)  << "\n";
}

您应该考虑这些变体是否适合您的使用：

• 使用引用而不是按值传递
• 使非可变模板采用两个参数而不是一个。

---

或者，这是一个非递归版本。可悲的是，它并没有短路。要查看非递归短路版本，请参阅其他答案。

template<typename T, typename... Args>
bool AreEqual(T first, Args... args)
{
  return std::min({first==args...});
}

---

最后，这个版本的吸引力在于它缺乏微妙之处：

template<typename T, typename... Args>
bool AreEqual(T first, Args... args)
{
  for(auto i : {args...})
    if(first != i)
      return false;
  return true;
}

Answer 2

由于您似乎出于某种原因排除了明智的做法，您也可以尝试使用std::initializer_list：

template<typename T>
bool AreEqual(std::initializer_list<T> list) {
    ...
}

那么你可以这样称呼它：

AreEqual({1,1,1,1,1});

Answer 3

这是一个非递归版本：

template <typename T> using identity = T;

template<typename T, typename... Args>
bool AreEqual(T first, Args... args)
{
  bool tmp = true;
  identity<bool[]>{tmp?tmp=first==args:true ...};
  return tmp;
}

启用优化后，与递归函数相比没有任何开销，只是行为可能有所不同，因为所有参数都与第一个参数进行比较。

Answer 4

使用

 bool AreEqual(int v1, ...);

但是，您需要以某种方式检测整数列表的结尾。如果有一个特定的整数值不能合法地传递给函数，那么就使用它。例如，如果所有整数都是正数，您可以使用-1 来标记结束。否则，您可以将第一个参数设为计数。

这是计数版本：

bool AreEqual(int count, int v1, ...)
{
     va_list vl;
     va_start(vl, count);
     for(int i = 1; i < count; ++i)
        if (va_arg(v1, int) != v1)
        {
            va_end(vl);
            return false;
        }
     va_end(vl);
     return true;
}

这是结束标记版本：

bool AreEqual(int v1, ...)
{
     va_list vl;
     va_start(vl, count);

     do
     {
         int param = va_arg(vl, int);
         if (param == -1)
         {
             va_end(vl);
             return true;
        }
    } while (param == v1);
    va_end(vl);
    return false;
}

Answer 5

可变参数模板需要对特化进行递归：

template<class A> //just two: this is trivial
bool are_equal(const A& a, const A& b)
{ return a==b; } 

template<class A, class... Others>
bool are_equal(const A& a, const A& b, const Others&... others)
{ return are_equal(a,b) && are_equal(b,others...); }

本质上，每次 are_equal 嵌套时，其他...都会短一直到 estinguish，并且该函数将绑定两个 args。

注意： 通过使用A 作为a 和b 的类型，并且因为Others 的第一个总是匹配一个A，这实际上使得are_equal(...) 只接受一个same 类型（至少，可转换为第一个参数的类型）。

虽然我喜欢这个约束通常很有用，但可以通过使用 A 和 B 作为 a 和 b 的类型来放松限制 这使得该函数适用于每对存在operator== 的每组类型。

template<class A, class B> //just two: this is trivial
bool are_equal(const A& a, const B& b)
{ return a==b; } 

template<class A, class B, class... Others>
bool are_equal(const A& a, const B& b, const Others&... others)
{ return are_equal(a,b) && are_equal(b,others...); }