mehrdeutig Vorlage Seltsamkeit

Question

Ich habe den folgenden Code (sorry für den großen Code Brocken, aber ich konnte es nicht mehr einengen)

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; 
} 

aber es funktioniert nicht mit gcc (v4.3) mit

kompilieren

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 

OK, so ist es mehrdeutig. aber ich habe nicht erwartet, dass es ein Problem ist, da es bei der Spezialisierung fast immer eine Zweideutigkeit geben wird. Dieser Fehler wird jedoch nur ausgelöst, wenn die Klasse mit enable_if<...> verwendet wird, wenn ich sie durch eine Klasse wie die folgende ersetze, gibt es kein Problem.

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

Warum verursacht diese Klasse keine Zweideutigkeit, während die anderen dies tun? Sind die beiden nicht dasselbe für Klassen mit einem wahren :: Wert? Wie auch immer, irgendwelche Hinweise darauf, was ich falsch mache, werden geschätzt.

Danke für die Antworten, mein eigentliches Problem (der Compiler, um meine erste Spezialisierung wählen) wurde durch Ersetzen struct Foo<X, Base<X>, void> mit struct Foo<X, Base<X>, typename enable_if< Base<X> >::type > gelöst, die die Art, wie ich will zu arbeiten scheint.

Answer 1

Der Kern Ihrer Frage ist, dass Sie haben:

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 

und Sie versuchen, passen sie

Foo<int, Base<int>, void> 

Offensichtlich beide Spezialisierungen Spiel (die erste mit X = int, der zweite mit X = int, Y = Base<int>).

Gemäß dem Standard, Abschnitt 14.5.4, wird, wenn es mehrere übereinstimmende Spezialisierungen gibt, eine partielle Ordnung (wie in 14.5.5.2 definiert) unter ihnen konstruiert und die am meisten spezialisierte wird verwendet. In Ihrem Fall ist keiner jedoch spezialisierter als der andere. (Einfach gesagt, eine Vorlage ist spezialisierter als eine andere, wenn Sie jeden Typ-Parameter der letzteren Vorlage durch einen Typ ersetzen können und im Ergebnis erhalten Sie die Signatur des ehemaligen. Wenn Sie whatever<Y>::type haben und Sie ersetzen Y durch Base<X> erhalten Sie whatever<Base<X> >::type nicht void, dh es gibt keine Verarbeitung durchgeführt wird.)

Wenn Sie #2 mit

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

dann der Kandidat beide Vorlagen enthält wieder eingestellt ersetzen, aber # 1 ist speziellere dann solche # 3 und als ist ausgewählt.

Answer 2

sind nicht Sie ein Symbol

< 

fehlt?

Answer 3

Ich glaube, Sie vermissen ein ‚<‘, sollte eine Vorlage wie folgt aussehen:

template< typename T > 
struct myStruct 
{}; 

//OR 

template< class T > 
struct myStruct 
{};