Teil Spezialisierung für variadische Vorlage muss zuerst nicht-variadische Template-Parameter

Question

Der folgende Code

#include <iostream> 
#include <utility> 

template<typename F, typename... T> 
struct Wrapper{ }; 

template<typename T> 
struct is_wrapper : std::false_type {}; 

template<typename... T> 
struct is_wrapper<Wrapper<T...>> : std::true_type {}; 

//template<typename F, typename... T> 
//struct is_wrapper<Wrapper<F, T...>> : std::true_type {}; 

int main() 
{ 
    Wrapper<int, double> w; 

    std::cout << is_wrapper<decltype(w)>::value << std::endl; 
} 

druckt 0. Wenn man jedoch die beiden Linien in der Mitte uncomments druckt er 1.

Warum doesn‘ t es immer 1 drucken? Sollte die zweite Teilspezialisierung nicht auch den Fall abdecken, der offenbar nur von der dritten (kommentierten) Teilspezialisierung abgedeckt wird?

Answer 1

Der Code sollte tatsächlich der Teilspezialisierung entsprechen; Der Standard hat dies nie wirklich verboten, aber Compiler haben eine Weile gebraucht, um variantenbasierte Vorlagen und deren Abzug richtig zu implementieren. GCC entspricht seit 4.9.0 und Clang ab 3.6. Der relevante Fehlerbericht für Clang ist #22191 (ich kann jedoch keine GCCs finden).

Answer 2

Normalerweise, wenn ich Templates schreibe, die spezialisiert sind, verwende ich zuerst eine Forward-Deklaration und deklariere die Fälle als Spezialisierungen. In Ihrem Fall verstehe ich, dass Sie versuchen, eine variadische Vorlage ohne den leeren Fall zu schreiben (dh eine variadische Vorlage, die mindestens einen Typ haben könnte).

Ihr Code überraschte mich, weil ich denke, dass Sie richtig sind, passt die volle variadic Spezialisierung Ihres Merkmals den Loch Fällen ... Zuerst habe ich versucht, eine Vorwärtsdeklaration Ihrer Merkmalklasse zu verwenden, und definieren Sie NUR die volle Variadic Spezialisierung (Wenn also der Parameter des Merkmals keine Wrapper Instanz ist, schlägt die Kompilierung fehl). Und das ist genau das, was hat aufgetreten, mich wieder enttäuschend:

#include <iostream> 
#include <utility> 

template<typename F , typename... T> 
struct Wrapper {}; 

template<typename T> 
struct is_wrapper; 

//template<typename T> 
//struct is_wrapper : std::false_type {}; 

template<typename... T> 
struct is_wrapper<Wrapper<T...>> : std::true_type {}; 

//template<typename F, typename... T> 
//struct is_wrapper<Wrapper<F, T...>> : std::true_type {}; 

using my_wrapper_type = Wrapper<int,double>; 

int main() 
{ 
    std::cout << std::boolalpha << is_wrapper<my_wrapper_type>::value << std::endl; 
}//"Invalid use of incomplete type" ^^^^^^^^^^^^^^^^^^^^^^^^^^^ 

Schließlich habe ich versucht, mit der Forward-Deklaration Methode in der Wrapper Klasse. Und überraschend, dass es funktioniert:

#include <iostream> 
#include <utility> 

template<typename... T> 
struct Wrapper; 

template<typename F, typename... T> 
struct Wrapper<F,T...>{ }; 


template<typename T> 
struct is_wrapper : std::false_type {}; 

template<typename... T> 
struct is_wrapper<Wrapper<T...>> : std::true_type {}; 

//template<typename F, typename... T> 
//struct is_wrapper<Wrapper<F, T...>> : std::true_type {}; 


using my_wrapper_type = Wrapper<int,double>; 

int main() 
{ 
    std::cout << std::boolalpha << is_wrapper<my_wrapper_type>::value << std::endl; 
} 

Diese Drucke:

wahr

Here ist der Code bei ideone läuft.

Mit freundlichen Grüßen, ich verstehe nicht, warum Ihr Code fehlschlägt und meins funktioniert. Es ist ein Compiler-Bug, oder gibt es etwas, was uns fehlt? Ich weiß es nicht.

Answer 3

Wenn ich gut Ihr Problem zu verstehen, es ist nur eine Spezialisierung Priorität,

is_wrapper<decltype(w)> 

Kann durch 2-Vorlage spezialisiert werden:

template<typename T> // exact specialization 
template<typename... T> // variadic specialization with one parameter 

In diesem Fall Compiler Priorität wählt die genaue Spezialisierung und so template ist in Ihrem Fall niemals instatiziert.