Non-static data members

Les membres de données non statiques sont déclarés dans une spécification de membre d'une classe.

class S
{
    int n;              // membre de données non statique
    int& r;             // membre de données non statique de type référence
    int a[2] = {1, 2};  // membre de données non statique avec initialiseur de membre par défaut (C++11)
    std::string s, *ps; // deux membres de données non statiques
    struct NestedS
    {
        std::string s;
    } d5;               // membre de données non statique de type imbriqué
    char bit : 2;       // champ de bits de deux bits
};

Toute déclaration simple est autorisée, à l'exception

• extern et register les spécificateurs de classe de stockage ne sont pas autorisés ;

• types incomplets , types de classes abstraites , et leurs tableaux ne sont pas autorisés : en particulier, une classe C ne peut pas avoir de membre de données non statique de type C , bien qu'elle puisse avoir un membre de données non statique de type C& (référence à C) ou C* (pointeur vers C );
• un membre de données non statique ne peut pas avoir le même nom que celui de la classe si au moins un constructeur déclaré par l'utilisateur est présent ;

De plus, bit-field les déclarations sont autorisées.

Disposition

Lorsqu'un objet d'une certaine classe C est créé, chaque membre de données non statique de type non-référence est alloué dans une partie de la représentation objet de C . Le fait que les membres référence occupent ou non un stockage est défini par l'implémentation, mais leur durée de stockage est la même que celle de l'objet dont ils sont membres.

Les exigences d'alignement peuvent nécessiter un remplissage entre les membres, ou après le dernier membre d'une classe.

Disposition standard

La séquence initiale commune de deux types de classes non-union à disposition standard est la plus longue séquence de membres de données non statiques et de champs de bits dans l'ordre de déclaration, commençant par la première entité de ce type dans chacune des classes, telle que

• les entités correspondantes ont des types compatibles de mise en page,
• les entités correspondantes ont les mêmes exigences d'alignement , et
• soit les deux entités sont des champs de bits de même largeur, soit aucune n'est un champ de bits.

struct A { int a; char b; };
struct B { const int b1; volatile char b2; }; 
// La séquence initiale commune de A et B est A.a, A.b et B.b1, B.b2
struct C { int c; unsigned : 0; char b; };
// La séquence initiale commune de A et C est A.a et C.c
struct D { int d; char b : 4; };
// La séquence initiale commune de A et D est A.a et D.d
struct E { unsigned int e; char b; };
// La séquence initiale commune de A et E est vide

Deux types de classes non-union à disposition standard sont dits layout-compatibles s'ils sont du même type en ignorant les qualifications cv, le cas échéant, s'ils sont des énumérations layout-compatibles (c'est-à-dire des énumérations avec le même type sous-jacent), ou si leur séquence initiale commune comprend chaque membre de données non statique et champ de bits (dans l'exemple ci-dessus, A et B sont layout-compatibles).

Deux unions standard-layout sont dites layout-compatible si elles ont le même nombre de membres de données non statiques et que les membres de données non statiques correspondants (dans n'importe quel ordre) ont des types layout-compatibles.

Les types de disposition standard ont les propriétés spéciales suivantes :

• Dans une union de disposition standard avec un membre actif de type classe non-union T1 , il est permis de lire un membre de données non statique m d'un autre membre de l'union de type classe non-union T2 à condition que m fasse partie de la séquence initiale commune de T1 et T2 (sauf que la lecture d'un membre volatile via une glvalue non volatile est indéfinie).
• Un pointeur vers un objet de type classe de disposition standard peut être reinterpret_cast en pointeur vers son premier membre de données non statique non-champ de bits (s'il a des membres de données non statiques) ou sinon vers l'un de ses sous-objets de classe de base (s'il en a), et vice versa. En d'autres termes, le remplissage n'est pas autorisé avant le premier membre de données d'un type de disposition standard. Notez que les règles de strict aliasing s'appliquent toujours au résultat d'un tel cast.
• La macro offsetof peut être utilisée pour déterminer le décalage de n'importe quel membre depuis le début d'une classe de disposition standard.

Initialisation des membres

Les membres de données non statiques peuvent être initialisés de l'une des deux manières suivantes :

struct S
{
    int n;
    std::string s;
    S() : n(7) {} // initialise directement n, initialise par défaut s
};

struct S
{
    int n = 7;
    std::string s{'a', 'b', 'c'};
    S() {} // default member initializer will copy-initialize n, list-initialize s
};

#include <iostream>
int x = 0;
struct S
{
    int n = ++x;
    S() {}                 // uses default member initializer
    S(int arg) : n(arg) {} // uses member initializer 
};
int main()
{
    std::cout << x << '\n'; // prints 0
    S s1;                   // default initializer ran
    std::cout << x << '\n'; // prints 1
    S s2(7);                // default initializer did not run
    std::cout << x << '\n'; // prints 1
}

struct X
{
    int a[] = {1, 2, 3};  // error
    int b[3] = {1, 2, 3}; // OK
};

struct node
{
    node* p = new node; // error: use of implicit or defaulted node::node() 
};

struct A
{
    A() = default;     // OK
    A(int v) : v(v) {} // OK
    const int& v = 42; // OK
};
A a1;    // error: ill-formed binding of temporary to reference
A a2(1); // OK (default member initializer ignored because v appears in a constructor)
         // however a2.v is a dangling reference

struct A;
extern A a;
struct A
{
    const A& a1{A{a, a}}; // OK
    const A& a2{A{}};     // erreur
};
A a{a, a};                // OK

Utilisation

Le nom d'un membre de données non statique ou d'une fonction membre non statique ne peut apparaître que dans les trois situations suivantes :

struct S
{
    int m;
    int n;
    int x = m;            // OK: implicit this-> allowed in default initializers (C++11)
    S(int i) : m(i), n(m) // OK: implicit this-> allowed in member initializer lists
    {
        this->f();        // explicit member access expression
        f();              // implicit this-> allowed in member function bodies
    }
    void f();
};

struct S
{
    int m;
    void f();
};
int S::*p = &S::m;       // OK: use of m to make a pointer to member
void (S::*fp)() = &S::f; // OK: use of f to make a pointer to member

struct S
{
    int m;
    static const std::size_t sz = sizeof m; // OK: m dans un opérande non évalué
};
std::size_t j = sizeof(S::m + 42); // OK: même s'il n'y a pas d'objet "this" pour m

Notes

Rapports de défauts

Les rapports de défauts modifiant le comportement suivants ont été appliqués rétroactivement aux normes C++ précédemment publiées.

Voir aussi