std:: is_const

std::is_const est un UnaryTypeTrait .

Si T est un type qualifié const (c'est-à-dire, const , ou const volatile ), fournit la constante membre value égale à true . Pour tout autre type, value est false .

Si le programme ajoute des spécialisations pour std::is_const ou std::is_const_v , le comportement est indéfini.

Paramètres du modèle

Modèle de variable d'assistance

Notes

Si T est un type référence alors is_const < T > :: value est toujours false . La manière correcte de vérifier la constance d'un type potentiellement référence est de supprimer la référence : is_const < typename remove_reference < T > :: type > .

Implémentation possible

template<class T> struct is_const          : std::false_type {};
template<class T> struct is_const<const T> : std::true_type {};

` a été préservé tel quel, conformément aux instructions. Aucune traduction n'a été effectuée sur le contenu à l'intérieur des balises ``, `
` ou `$`,\; et\; tous\; les\; termes\; spécifiques\; au\; C++\; ainsi\; que\; les\; balises\; HTML\; et\; attributs\; ont\; été\; conservés\; dans\; leur\; forme\; originale.$

Exemple

#include <type_traits>
static_assert(std::is_same_v<const int*, int const*>,
    "Rappelez-vous, la constance se lie étroitement à l'intérieur des pointeurs.");
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>,
    "Car le pointeur lui-même ne peut pas être modifié mais l'entier pointé peut l'être.");
static_assert(!std::is_const_v<const int*>,
    "Car le pointeur lui-même peut être modifié mais pas l'entier pointé.");
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()
{
    // Une fonction membre const est constante d'une manière différente :
    static_assert(!std::is_const_v<decltype(&S::foo)>,
        "Car &S::foo est un pointeur.");
    using S_mem_fun_ptr = void(S::*)() const;
    S_mem_fun_ptr sfp = &S::foo;
    sfp = &S::bar; // OK, peut être redirigé
    static_assert(!std::is_const_v<decltype(sfp)>,
        "Car sfp est le même type de pointeur et peut donc être redirigé.");
    const S_mem_fun_ptr csfp = &S::foo;
    // csfp = &S::bar; // Erreur
    static_assert(std::is_const_v<decltype(csfp)>,
        "Car csfp ne peut pas être redirigé.");
}

Voir aussi