C++类对象成员与静态成员的构造析构顺序及访问规则

苏见山

发布时间：2026-10-16 | 4人浏览过

原创

C++开发中常涉及类嵌套与静态资源管理。本文解析当类成员为另一类对象时，构造与析构函数的具体执行顺序；同时梳理静态成员变量在编译期的内存分配机制及类外初始化规范，并说明静态成员函数因无法区分所属对象而只能访问静态数据的限制。

类对象作为成员的执行顺序

当一个类的成员变量是另一个类的对象实例时，该成员被称为对象成员。这种嵌套关系下，创建包含对象成员的类实例时，构造与析构函数的调用次序对理解资源生命周期至关重要。

第1步：验证构造与析构顺序

目的：通过输出语句直观观察嵌套对象的初始化与销毁时间。 操作示例：构建 Phone 类（拥有有参构造函数）和 Person 类（以 Phone 为成员），并在测试函数中实例化 Person。

#include <iostream>
using namespace std;

class Phone {
public:
    Phone(string P_name) {
        p_name = P_name;
        cout << "Phone类有参构造" << endl;
    }
    ~Phone() {
        cout << "Phone析构" << endl;
    }
    string p_name;
};

class Person {
public:
    // 使用初始化列表构造成员对象
    Person(string m_Name, string p_Name)
        :m_name(m_Name), m_PName(p_Name) {
        cout << "Person构造" << endl;
    }
    ~Person() {
        cout << "Person析构" << endl;
    }
    string m_name;
    Phone m_PName;
};

void test01() {
    Person p1("张三", "华为nova7");
    // ... 省略后续赋值代码，重点观察控制台输出 ...
}
int main() {
    test01();
    return 0;
}

从执行结果可以看出，先调用对象成员的构造函数（即 Phone 类的构造），随后才调用本类构造函数（Person 类的构造）。这一过程确保了依赖对象在使用前已正确就绪。

第2步：确认析构逆序

规则：析构函数的调用顺序与构造相反。
表现：当 Person 对象生命周期结束时，系统会先调用本类析构函数（清理 Person 特有的资源），最后再调用对象成员的析构函数（清理 Phone 对象）。

静态成员的定义与特性

静态成员是在成员变量或函数前加上 static 关键字定义的。它们属于类级别而非对象级别，所有该类的对象共享同一份数据。

静态成员变量：在编译阶段分配内存，支持类内声明、类外初始化。
静态成员函数：属于整个类，只能访问静态成员变量，无法直接处理非静态数据。

第3步：实现静态成员变量的访问

入口：定义类成员并补充类外初始化逻辑。 动作：分别通过具体对象实例和类名作用域符进行读写。

class Person {
public:
    static int m_A; // 公共权限
private:
    static int m_B; // 私有权限
};

// 类外初始化：类型 类名::变量名 = 值;
int Person::m_A = 10;
int Person::m_B = 10;

void test01() {
    // 1. 通过对象访问
    Person p1;
    p1.m_A = 100;
    
    // 修改p1后，p2读取的值同步变化，证明共享同一块内存
    Person p2;
    cout << "p1.m_A = " << p1.m_A << endl; 
    cout << "p2.m_A = " << p2.m_A << endl;
    
    // 2. 通过类名直接访问
    cout << "m_A = " << Person::m_A << endl;
    // cout << Person::m_B << endl; // 编译错误：私有的不可访问
}

静态成员变量受访问权限控制（public/private），但在类内部始终可访问。必须在类外使用 类名::变量名 = 初始值; 的形式完成定义与分配。

第4步：使用静态成员函数

注意：由于静态成员函数不依赖于任何特定对象，因此它无法访问非静态成员变量（如 m_C），因为它无法确定要读取哪个对象的属性。

class Person {
public:
    static void func() {
        m_A = 100; // 可以访问静态成员
        // m_C = 20; // 错误：非静态成员变量
        cout << "static func called" << endl;
    }
private:
    static void func2() { /* 私有静态方法 */ }
};

void test() {
    Person p;
    p.func();       // 方式1：通过对象调用
    Person::func(); // 方式2：通过类名调用（推荐）
}

静态成员函数同样遵循访问权限。即使通过对象调用，也无法突破 private 限制。实际开发中，建议优先使用 类名::函数名 的方式调用，以明确其静态特性。