Template-Klasse teilweise Spezialisierung Syntax

Question

Das folgende grundlegende Beispiel der partiellen Template-Klasse Spezialisierung, genommen von this wiki page:

template <typename Key, typename Value> 
class KeyValuePair { /* something generic */ }; 

template <typename Key> 
class KeyValuePair<Key, bool> { /* something specific to Value=bool */ }; 

KeyValuePair<int> kvpi; 

erzeugt einen Compiler-Fehler:

prog.cpp:10:17: error: wrong number of template arguments (1, should be 2) KeyValuePair<int> kvpi; 

Warum? Was mache ich falsch ? Wie eine partielle Template-Klassenspezialisierung deklariert und instanziiert werden soll?

Ich erwarte, dass die Variable kvpi eine teilweise spezialisierte Vorlagenklasseninstanz vom Typ KeyValuePair<int,bool> ist.

Answer 1

Sie scheinen mit verwirrenden Teil-Spezialisierung zu sein Standardschablonenargumente. Es scheint weiterhin, dass Sie beides brauchen (aus Gründen, die nicht erwähnt werden, aber nicht wirklich wichtig sind). Obwohl nicht ganz intuitiv, es kann wie folgt erreicht werden:

#include <iostream> 

template <typename Key, typename Value = bool> 
class KeyValuePair 
{ 
public: 
    KeyValuePair() 
    { 
     std::cout << __PRETTY_FUNCTION__ << ':' << "original\n"; 
    } 
}; 

template <typename Key> 
class KeyValuePair<Key, bool> 
{ 
public: 
    KeyValuePair() 
    { 
     std::cout << __PRETTY_FUNCTION__ << ':' << "specialized\n"; 
    } 
}; 


int main() 
{ 
    KeyValuePair<int,int> kvp1; 
    KeyValuePair<int> kvp2; 
} 

Ausgabe

KeyValuePair<int, int>::KeyValuePair() [Key = int, Value = int]:original 
KeyValuePair<int, bool>::KeyValuePair() [Key = int, Value = bool]:specialized 

Das verwirrende Teil zu einigen ist die Standard-Argument-Spezifikation, sondern eine Vorlage, die folgt, die nie wirklich sehen Erfüllung mit diesem Standard-arg wegen der späteren Spezialisierung. In solchen Fällen bevorzuge ich die Forward-Deklaration der Vorlage mit ihrer Standardargumentliste. Zumindest für mich macht es das Lesen etwas leichter. Sie können sich (oder auch nicht) dazu entschließen, dasselbe zu tun, wenn Sie das Gefühl haben, dass es Klarheit bietet. So etwas wie:

template <typename Key, typename Value = bool> 
class KeyValuePair; 

template <typename Key, typename Value> 
class KeyValuePair 
{ 
public: 
    KeyValuePair() 
    { 
     std::cout << __PRETTY_FUNCTION__ << ':' << "original\n"; 
    } 
}; 

template <typename Key> 
class KeyValuePair<Key, bool> 
{ 
public: 
    KeyValuePair() 
    { 
     std::cout << __PRETTY_FUNCTION__ << ':' << "specialized\n"; 
    } 
}; 

Answer 2

Sie definieren Ihre teilweise Spezialisierung korrekt, aber die Vorlage erwartet 2 Argument und Sie bieten nur eine.

Sie Standardargument verwenden:

template <typename Key, typename Value = bool> 
class KeyValuePair {}; 

KeyValuePair<int> kvpi; 

zu ermöglichen, und Sie können Ihre Teil-Spezialisierung halten, wenn

benötigt

template <typename Key> 
class KeyValuePair<Key, bool> { /* something specific to Value=bool */ }; 

Answer 3

Die teilweise Template-Spezialisierung erlaubt es Ihnen nicht, einen Template-Parameter zu vergessen. Sie müssen schreiben:

KeyValuePair<int, bool> kvpib; 

und die korrekte Spezialisierung wird verwendet.

Aber Sie können die Vererbung verwenden, um zu erreichen, was Sie wollen:

template <typename Key> 
class KeyBoolPair : public KeyValuePair<Key, bool> {}; 

KeyBoolPair<int> kbpi; 

oder wenn Sie C++ 11 oder höher:

template <typename Key> 
using KeyBoolPairBis = KeyValuePair<Key, bool>; 

KeyBoolPairBis<int> kbpbi; 

Beispiel: http://coliru.stacked-crooked.com/a/5095fc5c358d291a