parziale specializzazione Template e ICC

Question

Si consideri il seguente codice:

template <class T, class U, class V> 
struct Foo { }; 

template <class T, class U> 
struct Foo<T, U, std::integral_constant<int, U::value>> { 
    static void print() 
    { 
    std::cerr << "instantiated"; 
    } 
}; 

template <class U> 
struct Foo<double, U, std::integral_constant<int, U::value>> { 
    static void print() 
    { 
    std::cerr << "instantiated special"; 
    } 
}; 

struct Bar { 
    static const int value = 0; 
}; 

int main(int argc, char ** argv) 
{ 
    using Baz = Foo<double, Bar, std::integral_constant<int, 0>>; 
    Baz::print(); 

    return 0; 
} 

Quando compilo questo con ICC 16.0.1, ricevo il seguente messaggio:

main.cpp(38): error: more than one partial specialization matches the template argument list of class "Foo<double, Bar, std::integral_constant<int, 0>>" 
      "Foo<T, U, std::integral_constant<int, U::value>>" 
      "Foo<double, U, std::integral_constant<int, U::value>>" 
    Baz::print(); 

Con clangore 3.7.1 e GCC 5.3.0 si compila (e viene stampato lo "speciale istanziato"). Si tratta di un bug in icc o il mio codice è errato? A me sembra chiaro che la seconda specializzazione è strettamente più specializzata della prima; è identico al primo diverso dal fatto che blocca il primo parametro del template.

Edit: dovrei aggiungere: se questo è un bug in icc, c'è una buona soluzione?

Answer 1

Sì, questo è un bug in ICC.

---

Entrambe le specializzazioni parziali corrispondono alla tua applicazione, in modo da andare nelle regole parziali modello ordinazione su due funzioni sintetizzati:

template <class T, class U> void f(Foo<T, U, std::integral_constant<int, U::value>); 
template <class U>   void f(Foo<double, U, std::integral_constant<int, U::value>); 

Le regole ordinamento parziale coinvolgono sintetizzare nuovi tipi per ogni argomento modello e tentano di fare deduzione con ogni sovraccarico rispetto al resto. Innanzitutto, tentiamo di dedurre U rispetto a Foo<_U1, _U2, std::integral_constant<int, _U2::value>>. Ciò non riesce, dal momento che _U1 non corrisponde a double. Quindi il primo sovraccarico non è almeno altrettanto specializzato del secondo. Successivamente, tentiamo di dedurre T e U contro Foo<double, _U3, std::integral_constant<int, _U3::value>>. Questo succede con T=double e U=_U3. Quindi il secondo sovraccarico è specializzato almeno quanto il primo.

Come risultato, il secondo sovraccarico è più specializzato rispetto al primo. C'è una parzializzazione parziale specialistica unica, che è quella che dovrebbe essere istanziata (ed è fatta da gcc e clang). L'incapacità di ICC di farlo è un bug.