std::is_const
Von cppreference.com
| Definiert in der Kopfdatei <type_traits> |
||
| template< class T > struct is_const; |
(seit C++11) | |
std::is_const ist ein UnaryTypeTrait.
Wenn T ein const-qualifizierter Typ ist (d. h. const oder const volatile), stellt er das Member-Konstante value mit dem Wert true bereit. Für jeden anderen Typ ist value false.
Wenn das Programm Spezialisierungen für std::is_const oder std::is_const_v hinzufügt, ist das Verhalten undefiniert.
Inhalt |
[bearbeiten] Template-Parameter
| T | - | ein zu prüfender Typ |
[bearbeiten] Hilfsvariablen-Template
| template< class T > constexpr bool is_const_v = is_const<T>::value; |
(seit C++17) | |
Abgeleitet von std::integral_constant
Member-Konstanten
| value [static] |
true, wenn T ein const-qualifizierter Typ ist, sonst false.(öffentliche statische Member-Konstante) |
Memberfunktionen
| operator bool |
konvertiert das Objekt zu bool, gibt value zurück (öffentliche Memberfunktion) |
| operator() (C++14) |
gibt value zurück (öffentliche Memberfunktion) |
Membertypen
| Typ | Definition |
value_type
|
bool |
type
|
std::integral_constant<bool, value> |
[bearbeiten] Anmerkungen
Wenn T ein Referenztyp ist, ist is_const<T>::value immer false. Der korrekte Weg, einen potenziellen Referenztyp auf Constness zu prüfen, ist das Entfernen der Referenz: is_const<typename remove_reference<T>::type>.
[bearbeiten] Mögliche Implementierung
template<class T> struct is_const : std::false_type {}; template<class T> struct is_const<const T> : std::true_type {}; |
[bearbeiten] Beispiel
Führen Sie diesen Code aus
#include <type_traits> static_assert(std::is_same_v<const int*, int const*>, "Remember, constness binds tightly inside pointers."); static_assert(!std::is_const_v<int>); static_assert(std::is_const_v<const int>); static_assert(!std::is_const_v<int*>); static_assert(std::is_const_v<int* const>, "Because the pointer itself can't be changed but the int pointed at can."); static_assert(!std::is_const_v<const int*>, "Because the pointer itself can be changed but not the int pointed at."); static_assert(!std::is_const_v<const int&>); static_assert(std::is_const_v<std::remove_reference_t<const int&>>); struct S { void foo() const {} void bar() const {} }; int main() { // A const member function is const in a different way: static_assert(!std::is_const_v<decltype(&S::foo)>, "Because &S::foo is a pointer."); using S_mem_fun_ptr = void(S::*)() const; S_mem_fun_ptr sfp = &S::foo; sfp = &S::bar; // OK, can be re-pointed static_assert(!std::is_const_v<decltype(sfp)>, "Because sfp is the same pointer type and thus can be re-pointed."); const S_mem_fun_ptr csfp = &S::foo; // csfp = &S::bar; // Error static_assert(std::is_const_v<decltype(csfp)>, "Because csfp cannot be re-pointed."); }
[bearbeiten] Siehe auch
| (C++11) |
prüft, ob ein Typ volatile-qualifiziert ist (Klassenvorlage) |
| (C++17) |
erhält eine Referenz auf const zu seinem Argument (Funktionsvorlage) |
