Non-static data members

Los miembros de datos no estáticos se declaran en una especificación de miembro de una clase.

class S
{
    int n;              // miembro de datos no estático
    int& r;             // miembro de datos no estático de tipo referencia
    int a[2] = {1, 2};  // miembro de datos no estático con inicializador de miembro predeterminado (C++11)
    std::string s, *ps; // dos miembros de datos no estáticos
    struct NestedS
    {
        std::string s;
    } d5;               // miembro de datos no estático de tipo anidado
    char bit : 2;       // campo de bits de dos bits
};

Cualquier declaración simple está permitida, excepto

• extern y register los especificadores de clase de almacenamiento no están permitidos;

• tipos incompletos , tipos de clase abstracta , y arreglos de estos no están permitidos: en particular, una clase C no puede tener un miembro de datos no estático de tipo C , aunque puede tener un miembro de datos no estático de tipo C& (referencia a C) o C* (puntero a C );
• un miembro de datos no estático no puede tener el mismo nombre que el nombre de la clase si hay presente al menos un constructor declarado por el usuario;

Además, bit-field las declaraciones están permitidas.

Diseño

Cuando se crea un objeto de alguna clase C , cada miembro de datos no estático de tipo no referencia se asigna en alguna parte de la representación del objeto de C . Si los miembros de referencia ocupan almacenamiento está definido por la implementación, pero su duración de almacenamiento es la misma que la del objeto en el que son miembros.

Los requisitos de alineación pueden requerir relleno entre los miembros, o después del último miembro de una clase.

Diseño-estándar

La secuencia inicial común de dos tipos de clase no unión de diseño estándar es la secuencia más larga de miembros de datos no estáticos y campos de bits en orden de declaración, comenzando con la primera de estas entidades en cada una de las clases, tal que

• las entidades correspondientes tienen tipos compatibles con el diseño,
• las entidades correspondientes tienen los mismos requisitos de alineación , y
• ambas entidades son campos de bits con el mismo ancho o ninguna es un campo de bits.

struct A { int a; char b; };
struct B { const int b1; volatile char b2; }; 
// La secuencia inicial común de A y B es A.a, A.b y B.b1, B.b2
struct C { int c; unsigned : 0; char b; };
// La secuencia inicial común de A y C es A.a y C.c
struct D { int d; char b : 4; };
// La secuencia inicial común de A y D es A.a y D.d
struct E { unsigned int e; char b; };
// La secuencia inicial común de A y E está vacía

Dos tipos de clase no unión de diseño estándar se denominan layout-compatible si son del mismo tipo ignorando los calificadores cv, si los hay, son enumeraciones layout-compatible (es decir, enumeraciones con el mismo tipo subyacente), o si su common initial sequence consiste en cada miembro de datos no estático y campo de bits (en el ejemplo anterior, A y B son layout-compatible).

Dos uniones de diseño estándar se denominan layout-compatible si tienen el mismo número de miembros de datos no estáticos y los miembros de datos no estáticos correspondientes (en cualquier orden) tienen tipos layout-compatible.

Los tipos de diseño estándar tienen las siguientes propiedades especiales:

• En una unión de diseño estándar con un miembro activo de tipo de clase no unión T1 , se permite leer un miembro de datos no estático m de otro miembro de la unión de tipo de clase no unión T2 siempre que m sea parte de la secuencia inicial común de T1 y T2 (excepto que leer un miembro volátil a través de un glvalue no volátil es indefinido).
• Un puntero a un objeto de tipo de clase de diseño estándar puede ser reinterpret_cast a un puntero a su primer miembro de datos no estático y no campo de bits (si tiene miembros de datos no estáticos) o de lo contrario a cualquiera de sus subobjetos de clase base (si tiene alguno), y viceversa. En otras palabras, no se permite relleno antes del primer miembro de datos de un tipo de diseño estándar. Nótese que las reglas de aliasing estricto aún se aplican al resultado de dicha conversión.
• La macro offsetof puede usarse para determinar el desplazamiento de cualquier miembro desde el inicio de una clase de diseño estándar.

Inicialización de miembros

Los miembros de datos no estáticos pueden inicializarse de una de dos maneras:

struct S
{
    int n;
    std::string s;
    S() : n(7) {} // direct-initializes n, default-initializes s
};

struct S
{
    int n = 7;
    std::string s{'a', 'b', 'c'};
    S() {} // el inicializador de miembro predeterminado inicializará n por copia, e inicializará s por lista
};

#include <iostream>
int x = 0;
struct S
{
    int n = ++x;
    S() {}                 // utiliza el inicializador de miembro predeterminado
    S(int arg) : n(arg) {} // utiliza el inicializador de miembro
};
int main()
{
    std::cout << x << '\n'; // imprime 0
    S s1;                   // se ejecutó el inicializador predeterminado
    std::cout << x << '\n'; // imprime 1
    S s2(7);                // no se ejecutó el inicializador predeterminado
    std::cout << x << '\n'; // imprime 1
}

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

struct node
{
    node* p = new node; // error: uso de node::node() implícito o predeterminado
};

struct A
{
    A() = default;     // OK
    A(int v) : v(v) {} // OK
    const int& v = 42; // OK
};
A a1;    // error: enlace incorrecto de temporal a referencia
A a2(1); // OK (el inicializador de miembro predeterminado se ignora porque v aparece en un constructor)
         // sin embargo a2.v es una referencia colgante

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

Uso

El nombre de un miembro de datos no estático o una función miembro no estática solo puede aparecer en las siguientes tres situaciones:

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: uso de m para crear un puntero a miembro
void (S::*fp)() = &S::f; // OK: uso de f para crear un puntero a miembro

struct S
{
    int m;
    static const std::size_t sz = sizeof m; // OK: m in unevaluated operand
};
std::size_t j = sizeof(S::m + 42); // OK: even though there is no "this" object for m

Notas

Informes de defectos

Los siguientes informes de defectos que modifican el comportamiento se aplicaron retroactivamente a los estándares de C++ publicados anteriormente.

Véase también