¿Es posible calcular el número factorial en tiempo de compilación, pero sin enumeraciones

Question

Quiero calcular factorial en tiempo de compilación. Encontré alguna manera de resolver el problema, pero quiero saber si hay alguna otra solución para este problema sin usar enum s. Aquí la solución que usa enum s.

#include <iostream> 
template <int n> 
struct fact 
{ 
    enum{value = n*fact<n-1>::value}; 
}; 

template<> 
struct fact<1> 
{ 
    enum{value = 1}; 
}; 

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

Si no hay otra solución, por favor describir por qué los enum s son imprescindible.

Answer 1

Si bien hay notaciones alternativas, está escrito de esa manera debido a que más compiladores aceptan que la notación de estilo de enumeración. El lenguaje admite miembros de la clase const integral-type con una inicialización en línea, pero algunos compiladores no son compatibles con el estándar en ese sentido. En los compiladores que son compatibles en este sentido, las siguientes obras muy bien:

#include <iostream> 
template <unsigned int n> 
struct fact 
{ 
    static const unsigned int value = n*fact<n-1>::value; 
}; 

template<> 
struct fact<0> 
{ 
    static const unsigned int value = 1; 
}; 

int main() 
{ 
    std::cout << fact<10>::value << "\n"; 
} 

Answer 2

Reemplazar,

enum{value}; 

con,

static int const value; // or unsigned int 

enum s son imprescindible, ya que supone que debe ser resuelto en tiempo de compilación. Lo que asegura que cualquier resultado que haya calculado debe haberse hecho en tiempo de compilación. Otro tipo es static int const (significa cualquier tipo integral).

Para ilustrar:

enum E { 
X = strlen(s); // is an error, because X is a compile time constant 
}; 

Answer 3

Como alternativa, puede utilizar los miembros static const:

template <unsigned int n> 
struct fact { static const unsigned int value = n * fact<n-1>::value; }