Non-static data members are declared in amember specification of a class.

class S{int n;// non-static data memberint& r;// non-static data member of reference typeint a[2]={1,2};// non-static data member with default member initializer (C++11)std::string s,*ps;// two non-static data members struct NestedS{std::string s;} d5;// non-static data member of nested type char bit:2;// two-bit bitfield};

Anysimple declarations are allowed, except

• extern andregister storage class specifiers are not allowed;

• incomplete types,abstract class types, and arrays thereof are not allowed: in particular, a classC cannot have a non-static data member of typeC, although it can have a non-static data member of typeC& (reference to C) orC* (pointer toC);
• a non-static data member cannot have the same name as the name of the class if at least one user-declared constructor is present;

In addition,bit-field declarations are allowed.

[edit]Layout

When an object of some classC is created, each non-static data member of non-reference type is allocated in some part of the object representation ofC. Whether reference members occupy any storage is implementation-defined, but theirstorage duration is the same as that of the object in which they are members.

Alignment requirements may necessitate padding between members, or after the last member of a class.

[edit]Standard-layout

Thecommon initial sequence of two standard-layout non-union class types is the longest sequence of non-static data members and bit-fields in declaration order, starting with the first such entity in each of the classes, such that

• corresponding entities have layout-compatible types,
• corresponding entities have the samealignment requirements, and
• either both entities are bit-fields with the same width or neither is a bit-field.

struct A{int a;char b;};struct B{constint b1;volatilechar b2;};// A and B's common initial sequence is A.a, A.b and B.b1, B.b2 struct C{int c;unsigned:0;char b;};// A and C's common initial sequence is A.a and C.c struct D{int d;char b:4;};// A and D's common initial sequence is A.a and D.d struct E{unsignedint e;char b;};// A and E's common initial sequence is empty

Two standard-layout non-union class types are calledlayout-compatible if they are the same type ignoring cv-qualifiers, if any, are layout-compatibleenumerations (i.e. enumerations with the same underlying type), or if theircommon initial sequence consists of every non-static data member and bit-field (in the example above,A andB are layout-compatible).

Two standard-layout unions are calledlayout-compatible if they have the same number of non-static data members and corresponding non-static data members (in any order) have layout-compatible types.

Standard-layout types have the following special properties:

• In a standard-layout union with an active member of non-union class typeT1, it is permitted to read a non-static data memberm of another union member of non-union class typeT2 providedm is part of the common initial sequence ofT1 andT2 (except that reading a volatile member through non-volatile glvalue is undefined).
• A pointer to an object of standard-layout class type can bereinterpret_cast to pointer to its first non-static non-bitfield data member (if it has non-static data members) or otherwise any of its base class subobjects (if it has any), and vice versa. In other words, padding is not allowed before the first data member of a standard-layout type. Note thatstrict aliasing rules still apply to the result of such cast.
• The macrooffsetof may be used to determine the offset of any member from the beginning of a standard-layout class.

[edit]Member initialization

Non-static data members may be initialized in one of two ways:

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 ranstd::cout<< x<<'\n';// prints 1    S s2(7);// default initializer did not runstd::cout<< x<<'\n';// prints 1}

struct X{int a[]={1,2,3};// errorint 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){}// OKconstint& v=42;// OK}; A a1;// error: ill-formed binding of temporary to referenceA 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}};// OKconst A& a2{A{}};// error}; A a{a, a};// OK

[edit]Usage

The name of a non-static data member or a non-static member function can only appear in the following three situations:

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 membervoid(S::*fp)()=&S::f;// OK: use of f to make a pointer to member

struct S{int m;staticconststd::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

[edit]Notes

[edit]Defect reports

The following behavior-changing defect reports were applied retroactively to previously published C++ standards.

[edit]See also

• In other languages

• Español
• 日本語
• Русский
• 中文