Non-static data members

Nicht-statische Datenelemente werden in einer Member-Spezifikation einer Klasse deklariert.

class S
{
    int n;              // nicht-statisches Datenelement
    int& r;             // nicht-statisches Datenelement vom Referenztyp
    int a[2] = {1, 2};  // nicht-statisches Datenelement mit Standard-Member-Initialisierer (C++11)
    std::string s, *ps; // zwei nicht-statische Datenelemente
    struct NestedS
    {
        std::string s;
    } d5;               // nicht-statisches Datenelement vom geschachtelten Typ
    char bit : 2;       // zweibit-Bitfeld
};

Jede einfache Deklaration ist erlaubt, außer

• extern und register Speicherklassenspezifizierer sind nicht erlaubt;

• unvollständige Typen , abstrakte Klassentypen und Arrays davon sind nicht erlaubt: Insbesondere kann eine Klasse C kein nicht-statisches Datenelement vom Typ C haben, obwohl sie ein nicht-statisches Datenelement vom Typ C& (Referenz auf C) oder C* (Zeiger auf C ) haben kann;
• ein nicht-statisches Datenelement kann nicht denselben Namen wie die Klasse haben, wenn mindestens ein benutzerdeklarierter Konstruktor vorhanden ist;

Zusätzlich sind Bitfeld -Deklarationen erlaubt.

Layout

Wenn ein Objekt einer Klasse C erstellt wird, wird jedes nicht-statische Datenelement vom Nicht-Referenztyp in einem Teil der Objektdarstellung von C allokiert. Ob Referenzelemente Speicher belegen, ist implementierungsdefiniert, aber ihre Speicherdauer ist dieselbe wie die des Objekts, zu dem sie gehören.

Ausrichtungsanforderungen können Auffüllungen zwischen Mitgliedern oder nach dem letzten Mitglied einer Klasse erforderlich machen.

Standard-Layout

Die gemeinsame Anfangssequenz von zwei Standard-Layout-Nicht-Union-Klassentypen ist die längste Folge von nicht-statischen Datenelementen und Bitfeldern in Deklarationsreihenfolge, beginnend mit der ersten solchen Entität in jeder der Klassen, so dass

• entsprechende Entitäten haben layout-kompatible Typen,
• entsprechende Entitäten haben dieselben Ausrichtungsanforderungen , und
• entweder sind beide Entitäten Bitfelder mit derselben Breite oder keine ist ein Bitfeld.

struct A { int a; char b; };
struct B { const int b1; volatile char b2; }; 
// Die gemeinsame Anfangssequenz von A und B ist A.a, A.b und B.b1, B.b2
struct C { int c; unsigned : 0; char b; };
// Die gemeinsame Anfangssequenz von A und C ist A.a und C.c
struct D { int d; char b : 4; };
// Die gemeinsame Anfangssequenz von A und D ist A.a und D.d
struct E { unsigned int e; char b; };
// Die gemeinsame Anfangssequenz von A und E ist leer

Zwei Standard-Layout-Klassen-Typen (non-union) werden als layout-kompatibel bezeichnet, wenn sie denselben Typ unter Ignorierung von CV-Qualifizierern haben, falls vorhanden, wenn sie layout-kompatible Enumerationen sind (d.h. Enumerationen mit demselben zugrundeliegenden Typ), oder wenn ihre gemeinsame Anfangssequenz aus jedem nicht-statischen Datenelement und Bitfeld besteht (im obigen Beispiel sind A und B layout-kompatibel).

Zwei Standard-Layout-Unions werden als layout-kompatibel bezeichnet, wenn sie die gleiche Anzahl von nicht-statischen Datenelementen haben und entsprechende nicht-statische Datenelemente (in beliebiger Reihenfolge) layout-kompatible Typen aufweisen.

Standard-Layout-Typen haben die folgenden besonderen Eigenschaften:

• In einer Standard-Layout-Union mit einem aktiven Member vom Nicht-Union-Klassentyp T1 ist es erlaubt, ein nicht-statisches Datenelement m eines anderen Union-Members vom Nicht-Union-Klassentyp T2 zu lesen, sofern m Teil der gemeinsamen Anfangssequenz von T1 und T2 ist (außer dass das Lesen eines volatile-Members durch einen nicht-volatile-Glvalue undefiniert ist).
• Ein Zeiger auf ein Objekt vom Standard-Layout-Klassentyp kann mittels reinterpret_cast in einen Zeiger auf sein erstes nicht-statisches Nicht-Bitfeld-Datenelement (falls es nicht-statische Datenelemente hat) oder andernfalls auf eines seiner Basisklassen-Subobjekte (falls vorhanden) umgewandelt werden, und umgekehrt. Mit anderen Worten, Padding vor dem ersten Datenelement eines Standard-Layout-Typs ist nicht erlaubt. Beachten Sie, dass die Strict-Aliasing-Regeln weiterhin auf das Ergebnis einer solchen Umwandlung angewendet werden.
• Das Makro offsetof kann verwendet werden, um den Offset eines beliebigen Members vom Anfang einer Standard-Layout-Klasse zu bestimmen.

Member-Initialisierung

Nicht-statische Datenelemente können auf eine von zwei Arten initialisiert werden:

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() {} // 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{}};     // Fehler
};
A a{a, a};                // OK

Verwendung

Der Name eines nicht-statischen Datenelements oder einer nicht-statischen Elementfunktion darf nur in den folgenden drei Situationen erscheinen:

struct S
{
    int m;
    int n;
    int x = m;            // OK: implizites this-> erlaubt in Standardinitialisierern (C++11)
    S(int i) : m(i), n(m) // OK: implizites this-> erlaubt in Mitgliedsinitialisierungslisten
    {
        this->f();        // expliziter Mitglied-Zugriffsausdruck
        f();              // implizites this-> erlaubt in Mitgliedsfunktionskörpern
    }
    void f();
};

struct S
{
    int m;
    void f();
};
int S::*p = &S::m;       // OK: Verwendung von m zur Bildung eines Zeigers auf Mitglied
void (S::*fp)() = &S::f; // OK: Verwendung von f zur Bildung eines Zeigers auf Mitglied

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

Hinweise

Fehlerberichte

Die folgenden verhaltensändernden Fehlerberichte wurden rückwirkend auf zuvor veröffentlichte C++-Standards angewendet.

Siehe auch