Ambigüedad de la plantilla C++

Question

Un amigo y yo estábamos discutiendo las plantillas C++. Me preguntó qué debería hacer esto:

#include <iostream> 

template <bool> 
struct A { 
    A(bool) { std::cout << "bool\n"; } 
    A(void*) { std::cout << "void*\n"; } 
}; 

int main() { 
    A<true> *d = 0; 
    const int b = 2; 
    const int c = 1; 
    new A<b> (c) > (d); 
} 

La última línea en main tiene dos análisis razonables. ¿Es 'b' el argumento de la plantilla o es b > (c) el argumento de la plantilla?

Aunque, es trivial compilar esto, y ver lo que obtenemos, nos preguntamos ¿qué resuelve la ambigüedad?

Answer 1

AFAIK se compilaría como new A<b>(c) > d. Esta es la única forma razonable de analizarlo en mi humilde opinión. Si el analizador no puede asumir bajo circunstancias normales a> finalizar un argumento de plantilla, eso generaría mucha más ambigüedad. Si usted quiere la otra manera, debería haber escrito:

new A<(b > c)>(d); 

Answer 2

La codicia del lexer es probablemente el factor determinante en la ausencia de paréntesis para hacerlo explícito. Supongo que el lexer no es codicioso.

Answer 3

estándar de C++ define que si por un nombre de plantilla seguido de un <, la < es siempre el comienzo de la lista de argumentos de plantilla y el primer no -nested > se toma como el final de la lista de argumentos de la plantilla.

Si pretendía que el resultado del operador > fuera el argumento de la plantilla, debería encerrar la expresión entre paréntesis. No necesita paréntesis si el argumento era parte de una static_cast<> u otra expresión de plantilla.

Answer 4

Según lo indicado por Leon & Lee, 14.2/3 (C++ '03) define explícitamente este comportamiento.

C++ '0x se agrega a la diversión con una regla similar que se aplica a >>. El concepto básico es que al analizar un argumento-lista de plantillas de un no anidada >> serán tratados como dos distintas >> fichas y no el derecho operador de desplazamiento:

template <bool> 
struct A { 
    A(bool); 
    A(void*); 
}; 

template <typename T> 
class C 
{ 
public: 
    C (int); 
}; 

int main() { 
    A<true> *d = 0; 
    const int b = 2; 
    const int c = 1; 
    new C <A<b>> (c) > (d); // #1 
    new C <A<b> > (c) > (d); // #2 
} 

'# 1' y '# 2' son equivalentes en lo anterior.

Esto, por supuesto, las correcciones que molestia de tener que añadir espacios en especializaciones anidados:

C<A<false>> c; // Parse error in C++ '98, '03 due to "right shift operator"