Заставить все && выполнить?

Question

рассмотрим следующую функцию VARIADIC

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?

Answer 1

Это не должно быть слишком трудно:

template <typename Type, typename... Types> 
bool f(Type& arg, Types&... args) 
{ 
    bool b1 = f(arg); 
    bool b2 = f(args...); 
    return b1 && b2; 
} 

Answer 2

Вы можете выполнять их по отдельности и возвращают логическое выражение:

bool b0 = f(arg); 
bool b1 = f(args); 
return b0 && b1; 

Answer 3

Без рекурсии:

template <typename... Types> 
bool f(Types&&... args) 
{ 
    bool r=true; 
    (void)std::initializer_list<bool>{(r = f(args)&&r)...}; 
    return r; 
} 

Answer 4

Существует В гораздо приятнее, вместо & & между всеми функциями, просто используйте один &

static_cast<bool>(f(arg)) & static_cast<bool>(f2(args)) ... будет выполнять все операции, независимо от результата :)

Answer 5

Поскольку дискуссия развивалась в сравнении решения AndyProwl и Алон, я ve сравнивает оба решения, а результат ... зависит от количества аргументов.

Компиляция с:

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 

тестов Решение Алон.

Вот программа эталонного теста для 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, как правило, быстрее, чем Алон один. Итак, теперь я могу подтвердить ваш ответ. Но я думаю, что разница настолько мала, что это зависит от архитектуры/компилятора.

Итак:

• AndyProwl + 1 для более быстрого решения, как правило
• Алон + 1 для constexpr готовые решения