A pesar de que ya se aceptó @iammilind 's respuesta, permítanme proponer otro, porque su razonamiento de por qué no se i tiempo de compilación constante es no era correcto.
Suponga que tiene
template<unsigned int MAX> struct SubDomain {...};
...
y desea declarar una instancia de ella ...
SubDomain<i> tmp(member);
continuación i debe haber un comúnmente denominado tiempo de compilación constante. ¿Que es eso?
Pedantería
La norma asigna el término nontype template argument a argumentos de plantilla que no son tipos (D'OH).
14.3.2 plantilla no de tipo argumentos [temp.arg.nontype]
Una plantilla-argumento para un no-tipo, no molde plantilla-parámetro deberá ser uno de:
- una expresión constante constante de tipo integral o de enumeración; o
- ... [más seguimiento, pero no son relevantes]
derecho en el primer punto contiene una referencia para futuras investigaciones: an integral constant-expression. Esto nos lleva a
5,19 Las expresiones constantes [expr.const]
En varios lugares, C + + requiere expresiones que se evalúan como una constante integral o enumeración: como matriz límites (8,3 .4, 5.3.4), como expresiones de caso (6.4.2), como longitudes de campo de bit (9.6), como inicializadores de enumerador (7.2), como inicializadores de miembros estáticos (9.4.2), y como integrantes o enumeración argumentos de plantilla sin tipo (14.3).
Entonces, la clave es:
Una constante-expresión integral puede implicar sólo literales (2.13), enumeradores, variables const o miembros de datos estáticos de tipos integrales o de enumeración inicializados con expresiones constantes (8.5), plantilla no de tipo parámetros de tipo integral o de enumeración, y tamaño de expresiones.
aplicación Pedantería
Si miramos hacia atrás en su bucle:
for (int i=...
...
SubDomain<i>
entonces ahora podemos observar que i no está permitido allí. ¿Por qué? Porque i NO es un const variable.
El lector que observa ahora podría pensar que se puede eludir esta:
for (int i=...
...
const int I = i;
SubDomain<I>
Pero es esto realmente permitido?Negativo, I = i no es una expresión de constante integral , porque i no lo es. Ayuda a darse cuenta de que la regla para expresiones constantes integrales se aplica recursivamente.
Por ejemplo, el siguiente es un código válido:
template <int> void foo() {}
int main() {
const int ccI = 0;
const int ccJ = ccI*2;
const int ccK = ccJ/4;
foo<ccK>();
}
Pero si hacer sólo una parte de la cadena no constante, entonces ccK no se considera integrante constante más:
template <int> void foo() {}
int main() {
int ccI = 0;
const int ccJ = ccI*2; // not compile time constant
const int ccK = ccJ/4; // same
foo<ccK>(); // error
}
Sumario
Así, en hu hombre forma legible, argumentos de plantilla que no son tipos, pero los valores (entero), debe ser en tiempo de compilación constante:
- el inicializador de un tiempo de compilación constante sólo se debe involucrar a otros en tiempo de compilación-constantes
- un valor literal es una compilación constante de tiempo
- un valor de enumeración es una compilación constante de tiempo
- la función de llamadas no dan compilación constantes de tiempo (por algunas razones avanzadas)
¿Lo has probado? ¿Qué quieres decir con válido? ¿Cuál es la pregunta? –
bueno en realidad ... las cosas son silenciosas y desordenadas en mi código en este momento ... –
@Jayesh, consulte la respuesta editada. Cometí un error en el código de demostración. – iammilind