Częściowa specjalizacja szablonu i ICC

Question

Rozważmy następujący kod:

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; 
} 

Kiedy skompilować to z MTK 16.0.1, pojawia się następujący komunikat:

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(); 

Z brzękiem i gcc 3.7.1 5.3.0 ta kompilacja (i "instancja specjalna" jest drukowana). Czy jest to błąd w Icc, czy mój kod jest niepoprawny? Wydaje mi się jasne, że druga specjalizacja jest ściśle wyspecjalizowana niż pierwsza; jest identyczny jak pierwszy, niż fakt, że blokuje pierwszy parametr szablonu.

Edit: Dodam: jeśli jest to błąd w MTK, czy istnieje dobry obejście?

Answer 1

Tak, jest to błąd w ICC.

---

Oba częściowe specjalizacje dopasować swoją realizację, więc idź do częściowych reguł szablon zamawiania na dwóch syntetyzowanych funkcji:

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>); 

cząstkowe zasady zamawiania polegają syntetyzowania nowych typów dla każdego argumentu szablonu i próbujących zrobić odliczenie z każdym przeciążeniem w stosunku do pozostałych. Najpierw próbujemy wywnioskować U przeciwko Foo<_U1, _U2, std::integral_constant<int, _U2::value>>. To się nie powiedzie, ponieważ _U1 nie pasuje do double. Zatem pierwsze przeciążenie nie jest tak wyspecjalizowane jak drugie. Następnie próbujemy wywnioskować T i U przeciwko Foo<double, _U3, std::integral_constant<int, _U3::value>>. Udaje się to z T=double i U=_U3. Więc drugie przeciążenie jest przynajmniej tak wyspecjalizowane jak pierwsze.

W rezultacie drugie przeciążenie jest bardziej wyspecjalizowane niż pierwsze. Istnieje unikalna najbardziej wyspecjalizowana częściowa partycjonowanie, która powinna być tworzona (i jest przez gcc i clang). Błąd ICC to błąd.