È legale di specializzarsi parzialmente classe interna template variadic con args dal modello variadic di una classe esterna

Question

Si consideri il codice:

#include <iostream> 

template <class... Ts> 
struct outer { 
    template <class... ITs> 
    struct inner { 
     static constexpr bool value = false; 
    }; 

    template <class... ITs> 
    struct inner<Ts..., ITs...> { 
     static constexpr bool value = true; 
    }; 
}; 

int main() { 
    std::cout << outer<int, float, double>::inner<int, float, double, int>::value << std::endl; 
} 

il codice viene compilato con clangore ++ ma non con g ++ dove si produce un errore:

temp3.cc:11:11: error: parameter pack argument ‘Ts ...’ must be at the end of the template argument list

struct inner<Ts..., ITs...> { 
    ^

Come ho già stabilito here la specializzazione parziale della classe interna dovrebbe essere legittima.

Edit: Per completezza vale la pena di aggiungere che clang per il codice di cui sopra avverte che si potrebbe avere un problema con i suoi parametri dedurre ancora farlo senza problemi ...

Answer 1

Questo è un bug gcc . Questa è una specializzazione parziale perfettamente valida:

template <class... ITs> 
struct inner<Ts..., ITs...> { 
    static constexpr bool value = true; 
}; 

parametri template dedurre pacchi devono essere scorso, e ITs... soddisfa che. Ma Ts... non è un pacchetto che deve essere dedotto qui, è solo un pacchetto di parametri specifici.

Inoltre, gcc compila diverse formulazioni equivalenti:

template <class... Ts> 
struct X { 
    template <class... Us> 
    static void foo(Ts..., Us...) { } 
}; 

int main() { 
    X<int>::foo(1, 'c'); 
} 

e:

template <class... Us> 
struct A { }; 

template <class... Ts> 
struct X { 
    template <class... Us> 
    static void foo(A<Ts..., Us...>) { } 
}; 

int main() { 
    X<int>::foo(A<int, char>{}); 
} 

presentate equivalentemente ben formate per tuo esempio originale.

Answer 2

possibile soluzione semplice ma efficace ispirato sulla risposta di Barry:

#include <iostream> 

template <class... Ts> 
struct pack { }; 

template <class... Ts> 
struct outer { 
    template <class IT> 
    struct inner { 
     static constexpr bool value = false; 
    }; 

    template <class... ITs> 
    struct inner<pack<Ts..., ITs...>> { 
     static constexpr bool value = true; 
    }; 
}; 

int main() { 
    std::cout << outer<int, float, double>::inner<pack<int, float, double, int>>::value << std::endl; 
} 

(Si produce ancora l'avviso in clang però)

Answer 3

Cavalcando la risposta di WF, mantenendo sempre lo stesso principale come nel domanda iniziale:

#include <iostream> 

template <class... Ts> 
struct pack { }; 

template <class... Ts> 
class outer { 
    template <class IT> 
    struct _inner { 
     static constexpr bool value = false; 
    }; 

    template <class... ITs> 
    struct _inner<pack<Ts..., ITs...>> { 
     static constexpr bool value = true; 
    }; 
public: 
    template <class... ITs> 
    struct inner { 
     static constexpr bool value = _inner<pack<ITs...>>::value; 
    };  
}; 

int main() { 
    std::cout << outer<int, float, double>::inner<int, float, double, int>::value 
      << std::endl; 
} 

Si produce ancora un avvertimento in clang, perché la versione specializzata di _inner non poteva dedurre la sua ... a parte l'elenco dei Ts ... , IT ... (in struct _inner<pack<Ts..., ITs...>>) - tuttavia il codice non richiede che gli IT siano dedotti separatamente dall'elenco di Ts ..., ITs ..., quindi dovrebbe essere ok.

In g ++ compila senza un avviso.

Codice: http://coliru.stacked-crooked.com/a/ae3b21dd847450b2

(Per una soluzione senza un avvertimento anche in clang: http://coliru.stacked-crooked.com/a/0c6c643c8ff5809e).