plantilla ambigua rareza

Question

tengo el siguiente código (lo siento por el gran trozo de código, pero no podía reducirlo más)

template <bool B> 
struct enable_if_c { 
     typedef void type; 
}; 

template <> 
struct enable_if_c<false> {}; 

template <class Cond> 
struct enable_if : public enable_if_c<Cond::value> {}; 

template <typename X> 
struct Base { enum { value = 1 }; }; 

template <typename X, typename Y=Base<X>, typename Z=void> 
struct Foo; 

template <typename X> 
struct Foo<X, Base<X>, void> { enum { value = 0 }; }; 

template <typename X, typename Y> 
struct Foo<X, Y, typename enable_if<Y>::type > { enum { value = 1 }; }; 

int main(int, char**) { 
     Foo<int> foo; 
} 

Pero falla al compilar con gcc (v4.3) con

foo.cc: In function ‘int main(int, char**)’: 
foo.cc:33: error: ambiguous class template instantiation for ‘struct Foo<int, Base<int>, void>’ 
foo.cc:24: error: candidates are: struct Foo<X, Base<X>, void> 
foo.cc:27: error:     struct Foo<X, Y, typename enable_if<Y>::type> 
foo.cc:33: error: aggregate ‘Foo<int, Base<int>, void> foo’ has incomplete type and cannot be defined 

Bien, entonces es ambiguo. pero no esperaba que fuera un problema, ya que al usar la especialización casi siempre habrá alguna ambigüedad. Sin embargo, este error solo se desencadena al usar la clase con enable_if<...>, si lo reemplazo con una clase como la siguiente no hay problema.

template <typename X, typename Y> 
struct Foo<X, Y, void > { enum { value = 2 }; }; 

¿Por qué esta clase no causa una ambigüedad mientras que las otras sí? ¿No son los dos lo mismo para las clases con un verdadero :: valor? De todos modos, cualquier sugerencia sobre lo que estoy haciendo mal se aprecia.

Gracias por las respuestas, mi problema real (para obtener el compilador para seleccionar la primera especialización) se resolvió mediante la sustitución de struct Foo<X, Base<X>, void> con struct Foo<X, Base<X>, typename enable_if< Base<X> >::type > que parece funcionar de la manera que quiero.

Answer 1

La esencia de su pregunta es que usted tiene:

template <typename X, typename Y, typename Z> 
struct Foo {}; 

template <typename X> 
struct Foo<X, Base<X>, void> {};     // #1 

template <typename X, typename Y> 
struct Foo<X, Y, typename whatever<Y>::type> {}; // #2 

y que está tratando de coincidir con

Foo<int, Base<int>, void> 

Obviamente, ambos coincidan especializaciones (el primero con X = int, el segundo con X = int, Y = Base<int>).

Según la norma, sección 14.5.4, si hay más especializaciones coincidentes, se construye una ordenación parcial (como se define en 14.5.5.2) entre ellas y se utiliza la más especializada. En su caso, sin embargo, ninguno es más especializado que el otro. (En pocas palabras, una plantilla es más especializada que otra, si puede reemplazar cada tipo de parámetro de la última plantilla con algún tipo y obtener la firma de la anterior. Además, si tiene whatever<Y>::type y reemplaza Y con Base<X>, obtiene whatever<Base<X> >::type no void, es decir, no hay tratamiento que se realizan.)

Si reemplaza #2 con

template <typename X, typename Y> 
struct Foo<X, Y, void > {};      // #3 

entonces el candidato ajustar de nuevo contiene ambas plantillas, sin embargo, # 1 es más especializado a continuación, # 3 y, como tal, está seleccionado.

Answer 2

no le faltaba un símbolo

< 

?

Answer 3

creo que le falta un '<', una plantilla debe verse como:

template< typename T > 
struct myStruct 
{}; 

//OR 

template< class T > 
struct myStruct 
{};