C++ C++；具有可变数量或参数的函数的静态编译

我发现自己在写这样的代码：

template <class T>
inline bool allequal(T a,T b,T c) {return a==b&&a==c;}
template <class T>
inline bool allequal(T a,T b,T c,T d) {return a==b&&a==c&&a==d;}
template <class T>
inline bool allequal(T a,T b,T c,T d,T e) {return a==b&&a==c&&a==d&&a==e;}

模板
内联bool allequal（ta，tb，tc）{返回a==b&&a==c；}
模板
内联bool allequal（ta，tb，tc，td）{返回a==b&&a==c&&a==d；}
模板
内联bool allequal（ta，tb，tc，td，te）{返回a==b&&a==c&&a==d&&a==e；}

我想知道是否有一种不使用向量或可变参数的自动化方法，因为在这种情况下速度很重要。

您可以尝试以下方法：

#include <iostream>

template< typename T >
inline bool allequal( const T& v )
{
  return true;
}

template< typename T, typename U, typename... Ts >
inline bool allequal( const T& v, const U& v1, const Ts&... Vs)
{
  return (v == v1) && allequal( v1, Vs... );
}

int main()
{
    std::cout << std::boolalpha;
    std::cout << allequal(1, 1, 1, 1) << std::endl;
    std::cout << allequal(1, 1, 2, 2) << std::endl;
    return 0;
}

#包括
模板
内联布尔阿莱奎尔（康斯特T&v）
{
返回true；
}
模板
内联bool allequal（常量T&v、常量U&v1、常量Ts和…Vs）
{
收益率（v==v1）和allequal（v1，Vs.）；
}
int main（）
{
std:：cout
#包含
模板
bool AllOf（第一个a，第二个b）
{
返回a==b；
}
模板
bool AllOf（第一个a，第二个b，其余…r）
{
返回a==b&&AllOf（b，r…）；
}
std:：cout那可变模板呢？你在用C++11吗？@Ninetaindo是的，我在用C++11。那会是什么样子？你能举个例子吗？你为什么认为可变模板会减慢代码的速度？@Jagannath，他说的不是可变模板，而是使用
va_arg
的可变参数，我猜。可变参数，不是模板他说的是
va_args
这将对
（1，1，2，2）
计算为真，而对
（1，2，3）
编译失败。你是说
allequal（v1，Vs.。
（和一个参数的递归停止符）如果类型不同，您可以与所有相同的
组合以
返回false；
。在C++17中，您可以使用
（（v==Vs）&&&…）
（并省略
v1
）；更多详细信息。clang 3.6使用
std=C++1z
接受它；我不确定gcc 5（4.9没有）。这是完美的答案。你能避免按值复制吗？我喜欢它背后的逻辑。但你不认为这将使用某种for循环进行编译，因此效率会低于其他解决方案吗？我必须分析它才能看到。其他两个答案都是递归的，这种方法是迭代的。请注意，它会短路，因此一旦当它发现两个
不等于
的元素时，它会提前退出，而不会遍历其余的元素。但是递归方法也会如此。
#include <algorithm>
#include <iterator>

template <typename T, typename... Args>
bool allequal(T a, Args... rest)
{
    std::initializer_list<T> values = {a, rest...};
    return std::adjacent_find(begin(values), end(values), std::not_equal_to<T>()) == end(values);
}

template<typename First, typename Second>
bool AllOf(First a, Second b)
{
    return a == b;
}

template<typename First, typename Second, typename... Rest>
bool AllOf(First a, Second b, Rest... r)
{
    return  a == b && AllOf(b, r...);
}


std::cout << AllOf(1, 1,1,1) << "\n";
std::cout << AllOf(1, 1,2) << "\n";
std::cout << AllOf(1,2) << "\n";
std::cout << AllOf(1,1) << "\n";