Posso usare decltype() per evitare la duplicazione del codice nelle istanze esplicite del modello?

Question

Ho una lunga dichiarazione di funzione template:

template <typename T> void foo(lots ofargs, goin here, andeven more, ofthese arguments, they just, dont stop); 

senza sovraccarichi. e voglio istanziarlo esplicitamente. Posso scrivere (diciamo per T = int):

template void foo<int>(lots ofargs, goin here, andeven more, ofthese arguments, they just, dont stop); 

Ma io davvero non voglio copiare quella lunga dichiarazione. Mi sarebbe piaciuto essere in grado di dire qualcosa del tipo:

template <typename T> using bar = decltype(foo<T>); 

e poi:

template bar<int>; 

Ora, la prima linea compila (GCC 4.9.3), ma la seconda linea doesn' t. Posso farlo funzionare in qualche modo? Oppure posso usare decltype() in qualche altro modo per evitare di copiare la dichiarazione per l'istanziazione?

Nota: Ho utilizzato in modo inteso un esempio in cui non è possibile dedurre il tipo solo dagli argomenti, poiché desidero che qualsiasi soluzione supporti anche questo caso.

Answer 1

Sicuro. Da [temp.explicit]:

La sintassi per istanziazione esplicita è:
        esplicita-esemplificazione:
                extern _opttemplatedichiarazione

.210

[...] Se l'istanza esplicita è per una funzione di funzione o membro, il qualificato-id nella dichiarazione deve essere o un modello-id o, dove tutti gli argomenti di template possono essere dedotte, un nome-modello o ID funzione operatore. [Nota: La dichiarazione può dichiarare una qualificato-id, nel qual caso il non qualificato-id del qualificata id deve essere un modello-id. -end note]

Abbiamo bisogno di una dichiarazione.Facciamo finta che stiamo iniziando con:

template <class T> void foo(T) { } 

Possiamo esplicitamente specializzati via solo:

template void foo<char>(char); // template-id 
template void foo(int);   // or just template-name, if the types can be deduced 

Questo è lo stesso di aver scritto:

using Fc = void(char); 
using Fi = void(int); 

template Fc foo<char>; 
template Fi foo; 

Che è lo stesso di avere scritto:

template <class T> using F = decltype(foo<T>); 

template F<char> foo<char>; 
template F<int> foo; 

Fondamentalmente, la ragione per cui template bar<int> non funziona è che non è una dichiarazione. Hai bisogno anche del nome.