Warum ist is_constructible Anspruch etwas ist konstruierbar, wenn es nicht ist?

Question

Das folgende Programm, wenn mit GCC 4.7 und clang 3.2 kompiliert, erzeugt "1" als Ausgabe.

#include <type_traits> 

struct foo { 
    template<typename T> 
    foo(T) { 
     static_assert(not std::is_same<int, T>(), "no ints please"); 
    } 
}; 

#include <iostream>  
int main() { 
    std::cout << std::is_constructible<foo, int>(); 
} 

Dies ist verwirrend. foo ist ganz eindeutig nicht konstruierbar von int! Wenn ich main der folgenden ändern, lehnen beide Compiler da es auf die statische Behauptung Versagen:

int main() { 
    foo(0); 
} 

Wie kommen beide Compiler sagen, es konstruierbar ist?

Answer 1

Dies ist, was der Standard (§20.9.5/6), mit Hervorhebung von mir zu sagen hat:

der folgenden Funktionsprototyp Gegeben:

für eine Vorlage

template <class T> 
typename add_rvalue_reference<T>::type create(); 

das Prädikat Bedingung Spezialisierung is_constructible<T, Args...> müssen erfüllt werden, wenn und nur wenn die folgende Variablendefinition wohlgeformt für einige erfunden werden würde Variable t:

T t(create<Args>()...); 

[Hinweis: Dieser Marker wird nie als Funktion Erklärung interpretiert. -Ende note]

Zugriffskontrolle ist, als ob in einem Kontext, in keinem Zusammenhang mit T und jedem der Args durchgeführt. Nur die Gültigkeit des unmittelbaren Kontextes der Variableninitialisierung wird berücksichtigt. [] Hinweis: Die Auswertung der Initialisierung kann zu Nebeneffekten wie der Instanziierung von Klassenvorlagenspezialisierungen und Funktionsvorlagenspezialisierungen führen, die Generierung implizit definierter Funktionen und so weiter. Solche Seite Effekte sind nicht im "unmittelbaren Kontext" und kann dazu führen, dass das Programm schlecht gebildet wird. -Ende note]

Die Behauptung, nicht nur, wenn die Vorlage Konstruktor instanziiert wird. Wie in der Anmerkung dargelegt, steht diese Behauptung jedoch nicht im unmittelbaren Zusammenhang mit der betrachteten Variablendefinition und hat somit keinen Einfluss auf deren "Gültigkeit". Daher können die Compiler diese Definition als gültig zählen und somit behaupten, dass foo tatsächlich von int konstruierbar ist, selbst wenn tatsächlich versucht wird, einen foo aus einem int zu konstruieren, was zu einem schlecht ausgebildeten Programm führt.

Beachten Sie, dass die Compiler sind auch erlaubt, statt is_constructible Ausbeute falsch, nur das ursprüngliche Programm auf der Behauptung zurückweisen, obwohl keiner tut.

Answer 2

foo2 ist Ihre foo. foo1 ist ein foo, das tut, was Sie Ihre foo tun möchten.

#include <type_traits> 
#include <utility> 

struct foo1 { 
    template<typename T,typename=typename std::enable_if< !std::is_same<int, T>::value >::type> 
    foo1(T) { 
    static_assert(not std::is_same<int, T>(), "no ints please"); 
    } 
}; 
struct foo2 { 
    template<typename T> 
    foo2(T) { 
    static_assert(not std::is_same<int, T>(), "no ints please"); 
    } 
}; 

#include <iostream>  
int main() { 
    std::cout << std::is_constructible<foo1, int>(); 
    std::cout << std::is_constructible<foo2, int>(); 
}