static_assert con il modello di specializzazione parziale

Question

template<typename T, typename U = void> 
struct S { /* static_assert(0, "type unsupported"); */ }; 
template<typename T> 
struct S<T, typename std::enable_if<std::is_integral<T>::value, void>::type> { 
    void foo() {} 
}; 
... 
S<int> i; 
i.foo(); 
S<double> d; 
// d.foo(); 

sarei aspettavo che il "schema generale" non sarebbe mai stato istanziato per il caso di int, ma se devo togliere il commento alla static_assert, l'istanza S<int> mancherò. Anche un solo typedef S<int> Si; non riuscirebbe a compilare. (GCC 4.9.2 Cygwin)

Quello che mirava a realizzare non è per S<double> a fallire alla chiamata foo(), ma l'istanza del modello stesso, e che con un messaggio di errore significativo. Sono consapevole che posso fare qualcosa come typename T::nonexistent_type t; nel modello principale che impedirà il modello per la compilazione, ma che sarebbe inferiore a un messaggio static_assert. (Nota: mettere il static_assert all'interno di una definizione di funzione nel modello maestro non riesce ancora compilation per S<int>)

Perché il static_assert non riuscire anche se questo modello non viene creata un'istanza? È questo mandato (o forse "non specificato") dallo standard? C'è un modo per fallire con un static_assert nel modo in cui desidero?

Answer 1

L'espressione nel numero static_assert deve dipendere da un parametro modello se si desidera che sia solo tempo di istanza. Questo è garantito da Standard, l'implementazione può (ma non ha alcun obbligo) di controllare i valori static_assertion s in modelli che non dipendono da alcun parametro del modello.

Il codice è un modo indiretto strano di fare qualcosa di simile

template<typename T> struct S { 
    static_assert(std::is_integral<T>::value, "type unsupported"); 
    void foo() {} 
}; 

Questo comunica chiaramente al compilatore la dipendenza tra l'espressione e il parametro del modello, ed è molto più chiaro e più facile da leggere pure. In realtà non riuscivo a capire se volevi che la compilazione fallisse per i tipi interi o per i tipi non integrali.