Come imporre l'uso della specializzazione del modello?

Question

Sto provando a far sì che la mia funzione template produca un errore in fase di compilazione se la versione base non specializzata è istanziata. Ho provato il solito schema di asserzione in fase di compilazione (dimensione array negativa) ma la compilazione ha esito negativo anche quando il modello non è istanziato. Qualche idea su come farlo fallire se e solo se la funzione template di base viene istanziata?

template<class Foo> void func(Foo x) { 
    // I want the compiler to complain only if this function is instantiated. 
    // Instead, the compiler is complaining here at the declaration. 
    int Must_Use_Specialization[-1]; 
} 

template<> void func(int x) { 
    printf("Hi\n"); 
} 

Answer 1

Basta usare Boost.StaticAssert

(Edit: o static_assert se si dispone di C++ 11 sostegno che ho dimenticato.).

Answer 2

Non definendolo è la soluzione più semplice:

template<class Foo> void func(Foo x); 

template<> void func(int x) { 
    printf("Hi\n"); 
} 

si può anche definire in file CPP e use this che funzionerà.

E metodo Assert static:

template<class Foo> void func(Foo x) { 
    static_assert(sizeof(Foo) != sizeof(Foo), "func must be specialized for this type!"); 
} 

Answer 3

Bisogna renderlo dipendente da Foo, in questo modo:

int Must_Use_Specialization[-sizeof(Foo)]; 

Answer 4

In C++ 11 è possibile utilizzare static_assert come questo:

template<typename T> struct fake_dependency: public std::false_type {}; 
template<class Foo> void func(Foo x) { 
    static_assert(fake_dependency<Foo>::value, "must use specialization"); 
} 

La struttura fake_dependency è necessaria per rendere dipendente l'asser sul parametro del modello, quindi attende con la valutazione, finché il modello non viene istanziato. È allo stesso modo possibile correggere la vostra soluzione in questo modo:

template<class> struct fake_dependency { enum {value = -1 }; }; 

template<class Foo> void func(Foo x) { 
    int Must_Use_Specialization[fake_dependency<Foo>::value]; 
} 

Vedi anche here for a live demo.

Answer 5

Non hai bisogno del modello di base se non lo utilizzerai mai! Basta fornire sovraccarichi per i tipi che si desidera utilizzare do!

void func(int x) { 
    printf("Hi 1\n"); 
} 

void func(double x) { 
    printf("Hi 2\n"); 
} 

void func(Bar x) { 
    printf("Hi 3\n"); 
} 

questo modo si ottiene un errore di compilazione per func(foo); (a meno che foo è convertibile in uno degli altri tipi).