C++ 类与对象基础：封装、实例化与 this 指针详解

通常将成员变量限制为 private 或 protected，仅将需要对外提供的功能设为 public。

![图示：类与结构体访问权限对比]

class 示例

class Stack {
public:
    void Init(int capacity = 4) {
        _a = nullptr;
        _top = 0;
        _capacity = 0;
    }
    void Push(int x) { /* ... */ }
private:
    int* _a;
    int _top;
    int _capacity;
};

int main() {
    Stack s1;
    s1.Init();
    s1.Push(1);
    // s1.top++; // 错误：无法访问私有成员
    return 0;
}

struct 示例

typedef struct A {
    void func() {}
    int a1;
    int a2;
} A;

struct B {
public:
    void Init() { /* ... */ }
private:
    int* _a;
    int _top;
    int _capacity;
};

int main() {
    struct A a1; // C 语言写法
    A a2;        // 重命名后写法
    B b1;        // 类写法
    return 0;
}

小贴士：虽然 struct 默认公有，但在 C++ 中仍推荐优先使用 class。除非一开始就希望所有成员公开（如链表节点定义）。

1.3 类域（作用域）

类定义了一个新的作用域。所有成员都在该作用域内。若在类外定义成员函数，必须使用 :: 域操作符指明所属类域，否则编译器会将其视为全局函数，导致找不到成员变量。

头文件 (Stack.h)

#pragma once
#include <iostream>

class Stack {
public:
    void Init(int capacity = 4);
    void Push(int x);
private:
    int* _a;
    int _top;
    int _capacity;
};

源文件 (Stack.cpp)

#include "Stack.h"

void Stack::Init(int capacity) {
    _a = nullptr;
    _top = 0;
    _capacity = capacity;
}

void Stack::Push(int x) {
    // ...
}

测试文件 (test.cpp)

#include "Stack.h"

int main() {
    Stack s1;
    s1.Init();
    return 0;
}

实例化

2.1 解密：实例化的重要'身份'

用类在物理内存中创建对象的过程称为实例化。类是对对象的抽象描述，定义了有哪些成员变量，但这些变量只是声明，未分配空间。只有实例化出对象时，才会分配实际内存。

可以将类比作建筑设计图，规划了房间大小和功能，但图纸本身不能住人；只有根据图纸建出的房子（对象）才能居住。同样，类不能存储数据，实例化后的对象才拥有存储数据的物理空间。

![图示：类与对象的关系]

class Stack {
public:
    void Init(int capacity = 4) {
        _a = nullptr;
        _top = 0;
        _capacity = capacity;
    }
    void Push(int x) { /* ... */ }
private:
    int* _a;
    int _top;
    int _capacity;
};

int main() {
    Stack s1; // 实例化对象 s1
    s1.Init();
    Stack s2; // 实例化对象 s2
    s2.Push(2);
    // 此时成员变量才会占用空间
    return 0;
}

2.2 探究：对象的大小

实例化出的对象包含独立的数据空间，因此肯定包含成员变量，但不包含成员函数。

函数被编译后是机器指令，存储在代码段（单独区域）。如果每个对象都存储一份函数副本，会造成巨大的空间浪费。实际上，多个对象调用的是同一个函数地址。编译器在编译链接时只需找到函数地址即可，无需在运行时查找（动态多态除外）。

对象大小计算遵循 C++ 的内存对齐规则。

![图示：内存对齐示意]

class A {
public:
    void Init(int n = 4) {}
private:
    char a;
    int y;
};

int main() {
    A s1;
    s1.Init();
    std::cout << sizeof(s1) << std::endl;
    std::cout << sizeof(A) << std::endl;
    return 0;
}

根据对齐规则，上述对象大小为 8 字节，并未包含成员函数。

对于空类或仅含成员函数的类，大小通常为 1 字节。这是为了占位，确保每个对象在内存中有唯一的地址标识，否则无法区分不同的对象实例。

this 指针

当类实例化多个对象并调用同一个成员函数时，如何区分是哪个对象？C++ 引入了隐含的 this 指针。

编译器会将成员函数的第一个参数隐式设置为当前类型的指针，即 this 指针。例如 void Init(Stack* const this, ...)。

访问成员变量的本质是通过 this 指针进行的，例如 this->_capacity = capacity;。 C++ 规定不能在实参和形参位置显式编写 this 指针（由编译器处理），但可以在函数体内使用。

#include <iostream>
using namespace std;

class Date {
public:
    void Init(int year, int month, int day) {
        this->_year = year;
        this->_month = month;
        _day = day;
    }
    void Print() {
        cout << _year << "/" << _month << "/" << _day << '\n';
    }
private:
    int _year;
    int _month;
    int _day;
};

int main() {
    Date d1;
    Date d2;
    d1.Init(2025, 7, 31);
    d2.Init(2025, 7, 9);
    d1.Print();
    d2.Print();
    return 0;
}

3.1 综合小测试

题目 1：下面的程序编译运行后的结果是？

class A {
public:
    void Print() {
        cout << this << endl;
        cout << "A::Print()" << endl;
    }
private:
    int _a;
};

int main() {
    A* p = nullptr;
    p->Print();
    return 0;
}

结果：C (正常运行)

这里对空指针 p 进行了解引用，但 Print 函数本身没有访问成员变量，只是输出了 this 指针的值。只要不访问 this 指向的对象内部数据，通常不会崩溃。

题目 2：下面程序编译运行结果是？

class A {
public:
    void Print() {
        cout << this << endl;
        cout << _a << endl; // 访问成员变量
    }
private:
    int _a;
};

int main() {
    A* p = nullptr;
    p->Print();
    return 0;
}

结果：B (运行崩溃)

这里访问了成员变量 _a，编译器将其转换为 this->_a。由于 this 为空指针，解引用会导致崩溃。

题目 3：this 指针存在内存哪个区域？

答案：A (栈)

this 指针类似于局部变量（形参），存储在栈区。但由于高频访问，现代编译器可能会将其优化到寄存器中。

C++ 和 C 语言实现 Stack 的对比

面向对象三大特性：封装、继承、多态。通过对比 C++ 与 C 语言的代码风格，可以更直观地理解封装的优势。

• 封装性：C++ 将数据和函数放在类中，通过访问限定符限制直接修改数据，提高了安全性。
• 语法便利：C++ 支持缺省参数（如 Init 的参数），且隐式的 this 指针使得调用时无需传递对象地址，类型使用也更简洁。
• 演进：虽然在入门阶段感觉 C++ 实现 Stack 变化较多，但随着学习深入（如适配器模式），其优势会更加明显。

总结

类、实例化与 this 指针共同构成了 C++ 面向对象编程的核心基础。这些机制实现了数据与方法的封装，让代码更具规范性与可读性。通过与 C 语言的对比，C++ 面向对象的设计优势得以直观体现。掌握这些知识，也为后续学习继承、多态等高级特性打下了坚实基础。