Non-static data members

非静态数据成员在类的 成员声明 中声明。

class S
{
    int n;              // 非静态数据成员
    int& r;             // 引用类型的非静态数据成员
    int a[2] = {1, 2};  // 带默认成员初始化器的非静态数据成员 (C++11)
    std::string s, *ps; // 两个非静态数据成员
    struct NestedS
    {
        std::string s;
    } d5;               // 嵌套类型的非静态数据成员
    char bit : 2;       // 两位位域
};

除以下情况外，允许任何 简单声明 ：

• extern 和 register 存储类说明符不允许使用；

• 不允许使用 不完整类型 、 抽象类类型 及其数组：特别地，类 C 不能拥有类型为 C 的非静态数据成员，但可以拥有类型为 C& （对 C 的引用）或 C* （指向 C 的指针）的非静态数据成员；
• 若存在至少一个用户声明的构造函数，则非静态数据成员不能与类名相同；

此外，允许使用 位域 声明。

布局

当某个类 C 的对象被创建时，每个非引用类型的非静态数据成员会被分配在 C 对象表示的某部分中。引用成员是否占用存储空间由实现定义，但其 存储期 与它们所属对象的存储期相同。

对齐要求可能需要在类成员之间或最后一个成员之后添加填充。

标准布局

两个标准布局非联合类类型的 公共起始序列 是指：从每个类的首个非静态数据成员或位域开始，按声明顺序构成的最长非静态数据成员与位域序列，且满足以下条件：

• 对应实体具有布局兼容的类型，
• 对应实体具有相同的 对齐要求 ，且
• 两个实体要么都是具有相同宽度的位域，要么都不是位域。

struct A { int a; char b; };
struct B { const int b1; volatile char b2; }; 
// A 和 B 的公共初始序列是 A.a, A.b 与 B.b1, B.b2
struct C { int c; unsigned : 0; char b; };
// A 和 C 的公共初始序列是 A.a 与 C.c
struct D { int d; char b : 4; };
// A 和 D 的公共初始序列是 A.a 与 D.d
struct E { unsigned int e; char b; };
// A 和 E 的公共初始序列为空

两个标准布局非联合类类型被称为 布局兼容 ，如果它们是忽略cv限定符（若存在）后的相同类型，是布局兼容的 枚举 （即具有相同底层类型的枚举），或者它们的 公共初始序列 包含所有非静态数据成员和位域（在上例中， A 和 B 是布局兼容的）。

两个标准布局联合体若满足以下条件则称为 布局兼容 ：它们具有相同数量的非静态数据成员，且对应的非静态数据成员（以任意顺序）具有布局兼容的类型。

标准布局类型具有以下特殊属性：

• 在具有非联合类类型 T1 活跃成员的标准布局联合体中，允许读取另一个非联合类类型 T2 联合体成员的非静态数据成员 m ，前提是 m 属于 T1 和 T2 的公共起始序列（但通过非 volatile 泛左值读取 volatile 成员是未定义行为）。
• 指向标准布局类类型对象的指针可以被 reinterpret_cast 转换为其第一个非静态非位域数据成员（如果存在非静态数据成员）或其任何基类子对象（如果存在基类）的指针，反之亦然。换言之，标准布局类型的第一个数据成员之前不允许存在填充。注意 严格别名 规则仍适用于此类转换结果。
• 宏 offsetof 可用于确定标准布局类中任意成员相对于类起始位置的偏移量。

成员初始化

非静态数据成员可以通过以下两种方式之一进行初始化：

struct S
{
    int n;
    std::string s;
    S() : n(7) {} // 直接初始化 n，默认初始化 s
};

struct S
{
    int n = 7;
    std::string s{'a', 'b', 'c'};
    S() {} // 默认成员初始化器将拷贝初始化 n，列表初始化 s
};

#include <iostream>
int x = 0;
struct S
{
    int n = ++x;
    S() {}                 // 使用默认成员初始化器
    S(int arg) : n(arg) {} // 使用成员初始化器
};
int main()
{
    std::cout << x << '\n'; // 输出 0
    S s1;                   // 默认初始化器已执行
    std::cout << x << '\n'; // 输出 1
    S s2(7);                // 默认初始化器未执行
    std::cout << x << '\n'; // 输出 1
}

struct X
{
    int a[] = {1, 2, 3};  // 错误
    int b[3] = {1, 2, 3}; // 正确
};

struct node
{
    node* p = new node; // 错误：使用了隐式或默认的 node::node()
};

struct A
{
    A() = default;     // 正确
    A(int v) : v(v) {} // 正确
    const int& v = 42; // 正确
};
A a1;    // 错误：将临时量绑定到引用无效
A a2(1); // 正确（因 v 出现在构造函数中，默认成员初始化器被忽略）
         // 但 a2.v 是悬垂引用

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

用法

非静态数据成员或非静态成员函数的名称仅可出现在以下三种情形中：

struct S
{
    int m;
    int n;
    int x = m;            // OK: 默认初始化器中允许隐式 this-> (C++11)
    S(int i) : m(i), n(m) // OK: 成员初始化列表中允许隐式 this->
    {
        this->f();        // 显式成员访问表达式
        f();              // 成员函数体中允许隐式 this->
    }
    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; // 正确：m 位于未求值操作数中
};
std::size_t j = sizeof(S::m + 42); // 正确：即使 m 没有对应的 "this" 对象

注释

缺陷报告

以下行为变更缺陷报告被追溯应用于先前发布的C++标准。

参见