suma - Cálculo e impresión factorial en tiempo de compilación en C++

programa que calcule el factorial de un numero en java

Question

template<unsigned int n>
struct Factorial {
    enum { value = n * Factorial<n-1>::value};
};

template<>
struct Factorial<0> {
    enum {value = 1};
};

int main() {
    std::cout << Factorial<5>::value;
    std::cout << Factorial<10>::value;
}

el programa anterior calcula el valor factorial durante el tiempo de compilación. Quiero imprimir valor factorial en tiempo de compilación en lugar de en tiempo de ejecución usando cout. ¿Cómo podemos lograr imprimir el valor factorial en tiempo de compilación?

Estoy usando VS2009.

¡Gracias!

Answer 1

Estoy aprendiendo los conceptos básicos de TMP y quiero saber el resultado en compilación para asegurarme de que la lógica sea correcta.

En ese caso, lo que realmente quieres es una afirmación estática:

static_assert(Factorial<5> ::value ==     120,  "5! should be 120");
static_assert(Factorial<10>::value == 3628800, "10! should be 3628800");

Si su compilador aún no admite static_assert , puede usar BOOST_STATIC_ASSERT .

Answer 2

Definitivamente no hay una forma estándar. No puedo pensar en una forma específica del compilador tampoco.

[[Relleno]]

Answer 3

El factorial se puede imprimir en un mensaje generado por el compilador como:

template<int x> struct _;
int main() {
        _<Factorial<10>::value> __;
        return 0;
}

Mensaje de error:

prog.cpp: 14: 32: error: aggregate ''_ <3628800> __'' tiene un tipo incompleto y no se puede definir _ :: value> __; ^

Aquí 3628800 es factorial de 10 .

Véalo en ideone: http://ideone.com/094SJz

Entonces, ¿estás buscando esto?

EDITAR:

Matthieu pidió un truco inteligente para imprimir el factorial Y dejar que la compilación continúe. Aquí hay un intento. No da ningún error, por lo tanto, la compilación tiene éxito con una advertencia.

template<int factorial> 
struct _{ operator char() { return factorial + 256; } }; //always overflow
int main() {
        char(_<Factorial<5>::value>());
        return 0;
}

Se compila con esta advertencia:

main.cpp: en la instanciación de ''_ :: operator char () [con int factorial = 120]'' : main.cpp: 16: 39: requerido desde aquí main.cpp: 13: 48: warning: desbordamiento en conversión constante implícita [-Woverflow] struct _ {operator char () {return factorial + 256; }}; // siempre desbordamiento

Aquí 120 es factorial de 5 .

Demostración en ideone: http://coliru.stacked-crooked.com/a/c4d703a670060545

Podrías simplemente escribir una bonita macro y usarla como:

#define PRINT_AS_WARNING(constant) char(_<constant>())    

int main() 
{
         PRINT_AS_WARNING(Factorial<5>::value);
         return 0;
}

Eso se ve genial