c++ - que - saber si un numero es multiplo en c

¿Es posible escribir una plantilla de función que devuelva si el número de argumentos es divisible por N?

Question

He estado aprendiendo acerca de las plantillas variadas y, con la ayuda de esta excelente publicación de blog , logré escribir una plantilla de función even_number_of_args que devuelve si el número de argumentos que recibe es divisible por 2.

#include <iostream>

bool even_number_of_args() {
    return true;
}

template <typename T>
bool even_number_of_args(T _) {
    return false;
}

template<typename T, typename U, typename... Vs>
bool even_number_of_args(T _, U __, Vs... vs) {
  return even_number_of_args(vs...);
}

int main() {
    std::cout << even_number_of_args()                   << std::endl; // true
    std::cout << even_number_of_args(1)                  << std::endl; // false
    std::cout << even_number_of_args(1, "two")           << std::endl; // true
    std::cout << even_number_of_args(1, "two", 3.0)      << std::endl; // false
    std::cout << even_number_of_args(1, "two", 3.0, ''4'') << std::endl; // true
}

Me preguntaba si era posible escribir una plantilla de función que tome, como un argumento de plantilla, un número N y devuelva si el número de argumentos que recibe es un múltiplo de N Por ejemplo, la función puede verse algo como esto:

number_of_args_divisible_by_N<1>(1, "two", 3.0, ''4''); // true
number_of_args_divisible_by_N<2>(1, "two", 3.0, ''4''); // true
number_of_args_divisible_by_N<3>(1, "two", 3.0, ''4''); // false
number_of_args_divisible_by_N<4>(1, "two", 3.0, ''4''); // true

Answer 1

Aunque la solución de krzaq es bastante buena, creo que implementar la "magia" detrás de sizeof... puede servir como un interesante ejercicio de aprendizaje.

Utiliza una técnica que es muy común en la meta-programación de plantillas: una función que no es de plantilla que cubre el caso base y una función de plantilla que reduce el problema en un solo paso:

// Base case
int count_args() {
    return 0;
}
// Reduction
template<typename T, typename... Vs>
int count_args(T _, Vs... vs) {
    return 1 + count_args(vs...);
}

Con esta funcionalidad implementada, puede implementar el verificador de divisibilidad utilizando el enfoque de la respuesta de krzaq:

template<int N,typename... Vs>
bool is_arg_divisible(Vs... vs) {
    return count_args(vs...) % N == 0;
}

Demo.

Answer 2

Si es tan simple como

template<int N, typename... Ts>
constexpr bool number_of_args_divisible_by(Ts&&...)
{
    return sizeof...(Ts) % N == 0;
}

Alternativamente, puede devolver un tipo más amigable a la metaprogramación:

template<int N, typename... Ts>
constexpr integral_constant<bool, sizeof...(Ts) % N == 0>
number_of_args_divisible_by(Ts&&...)
{
    return {};
}