考虑以下可变参数函数
template <typename Type, typename... Types>
bool f(Type& arg, Types&... args)
{
return f(arg) && f(args...);
}
template <typename Type>
bool f(Type& arg)
{
// Do something
}
如果一级递归是false，那么我怀疑下面不会执行。是否有一种技巧可以强制对所有参数进行递归，即使其中一个返回 false ？
【问题讨论】：
&替换&&怎么样？
标签： c++ templates c++11 logic variadic-templates
这应该不会太难：
template <typename Type, typename... Types>
bool f(Type& arg, Types&... args)
{
bool b1 = f(arg);
bool b2 = f(args...);
return b1 && b2;
}
【讨论】：
f 的第二次调用。
f(arg)？不应该只是bool b1 = arg吗？
随着争论在 AndyProwl 和 Alon 解决方案的比较中不断发展，我对这两种解决方案进行了基准测试，结果...取决于参数的数量。
编译：
g++-4.7 -std=c++11 -Wall -Wextra -O3 main.cpp -o main -D_FIRST
对 AndyProwl 解决方案进行基准测试并使用：
g++-4.7 -std=c++11 -Wall -Wextra -O3 main.cpp -o main -D_SECOND
对 Alon 解决方案进行基准测试。
这是 10 个参数的基准测试程序。
#include <iostream>
#include <chrono>
// Function 1 : with &&
template <typename Type>
inline bool f1(const Type& arg)
{
return arg;
}
template <typename Type, typename... Types>
inline bool f1(const Type& arg, const Types&... args)
{
bool arg1 = f1(arg);
bool arg2 = f1(args...);
return arg1 && arg2;
}
// Function 2 : with &
template <typename Type>
inline bool f2(const Type& arg)
{
return arg;
}
template <typename Type, typename... Types>
inline bool f2(const Type& arg, const Types&... args)
{
return f2(arg) & f2(args...);
}
// Benchmark
int main(int argc, char* argv[])
{
// Variables
static const unsigned long long int primes[10] = {11, 13, 17, 19, 23, 29, 31, 37, 41, 43};
static const unsigned long long int nbenchs = 50;
static const unsigned long long int ntests = 10000000;
unsigned long long int sum = 0;
double result = 0;
double mean = 0;
std::chrono::high_resolution_clock::time_point t0 = std::chrono::high_resolution_clock::now();
// Loop of benchmarks
for (unsigned long long int ibench = 0; ibench < nbenchs; ++ibench) {
// Initialization
t0 = std::chrono::high_resolution_clock::now();
sum = 0;
// Loop of tests
for (unsigned long long int itest = 1; itest <= ntests; ++itest) {
#ifdef _FIRST
sum += f1((itest+sum)%primes[0], (itest+sum)%primes[1], (itest+sum)%primes[2], (itest+sum)%primes[3], (itest+sum)%primes[4], (itest+sum)%primes[5], (itest+sum)%primes[6], (itest+sum)%primes[7], (itest+sum)%primes[8], (itest+sum)%primes[9]);
#endif
#ifdef _SECOND
sum += f2((itest+sum)%primes[0], (itest+sum)%primes[1], (itest+sum)%primes[2], (itest+sum)%primes[3], (itest+sum)%primes[4], (itest+sum)%primes[5], (itest+sum)%primes[6], (itest+sum)%primes[7], (itest+sum)%primes[8], (itest+sum)%primes[9]);
#endif
}
// Finalization
result = std::chrono::duration_cast<std::chrono::duration<double>>(std::chrono::high_resolution_clock::now()-t0).count();
mean += result;
std::cout<<"time = "<<result<<" (sum = "<<sum<<")"<<std::endl;
}
// End
std::cout<<"mean time = "<<mean/nbenchs<<std::endl;
return 0;
}
对于具有给定参数数量的每个解决方案有 50 个基准，离散度非常小，这些基准的平均时间是一个可靠的指标。
我的第一个基准测试是使用“正确”数量的参数，其中 Alon 解决方案比 AndyProwl 解决方案更快。
最终结果在这里：
因此，AndyProwl 解决方案通常比 Alon 解决方案更快。所以，现在我可以验证你的答案。但我认为差异是如此之小，以至于它依赖于架构/编译器。
所以：
【讨论】：
你可以分别执行它们并返回一个布尔表达式：
bool b0 = f(arg);
bool b1 = f(args);
return b0 && b1;
【讨论】：
没有递归：
template <typename... Types>
bool f(Types&&... args)
{
bool r=true;
(void)std::initializer_list<bool>{(r = f(args)&&r)...};
return r;
}
【讨论】：
还有一个更好的技巧， 而不是在所有函数之间使用 &&，只需使用一个 &
static_cast<bool>(f(arg)) & static_cast<bool>(f2(args))
...无论结果如何，都会运行所有操作:)
【讨论】：
static_cast<bool> 修复。我喜欢这种方法，因为它比带有辅助变量的方法更紧凑。
& 是不是 通常用于逻辑连词。你不必接受我的回答，只是请不要从中学习。
bool 和按位 &.