1.1 唯一的区别：默认可见性#

在 C++ 编译器眼中，class 和 struct 的区别仅仅在于默认的访问权限（Access Modifier）：

• Class：成员默认为 private。
• Struct：成员默认为 public。

1
class Player {
2
    int x, y; // 默认为 Private，外部无法直接访问
3
public:
4
    void Move(int xa, int ya);
5
};
6

7
struct Vector2 {
8
    int x, y; // 默认为 Public，外部可以直接访问
9
};

1.2 业界惯例（Best Practices）#

虽然技术上你可以用 struct 做任何 class 能做的事（包括继承、虚函数等），但为了代码的可读性，C++ 开发者通常遵循以下约定：

• 使用 Struct：当通过它来表示一组纯粹的数据集合（POD - Plain Old Data），只包含数据成员，几乎没有复杂的方法逻辑时。例如：坐标点、颜色值、数据包。
• 使用 Class：当对象包含复杂的逻辑、私有数据、或者涉及继承体系时。

2.1 场景一：在类/结构体外部（Internal Linkage）#

当你在 .cpp 文件中（全局作用域）定义一个 static 变量或函数时。

• 含义：“不要让链接器（Linker）看到我。”
• 作用：该变量/函数只在当前编译单元（当前的 .cpp 文件）内部可见。
• 应用：这类似于许多语言中的 private 模块级变量。如果你在 A.cpp 和 B.cpp 中都定义了 static int s_Variable，它们是互不干扰的两个独立变量。如果不加 static，链接器在合并目标文件时会报“重复符号”（Duplicate Symbol）错误。

2.2 场景二：在类/结构体内部（Shared Memory）#

当 static 出现在类定义内部时。

• 含义：“这个成员属于类本身，而不是属于某个对象。”
• 内存机制：无论你实例化了多少个对象（甚至一个都不实例化），static 成员变量在内存中只有一份。所有对象共享这一份数据。
• 静态方法：
  • 静态方法没有 this 指针。
  • 因此，静态方法无法访问类中的非静态成员（因为它不知道该去读哪个对象的 x 或 y）。

代码演示：

1
struct Entity {
2
    int x, y;           // 实例变量：每个对象都有独立的 x, y
3
    static int sharedX; // 静态变量：所有对象共用这一个 sharedX
4

5
    static void Print() {
6
        // std::cout << x << std::endl; // ❌ 错误！无法访问非静态成员
7
        std::cout << sharedX << std::endl; // ✅ 正确！大家共用一个
8
    }
9
};
10

11
// 【重要】静态成员变量必须在类外定义，否则链接器找不到符号
12
int Entity::sharedX;
13

14
int main() {
15
    Entity::sharedX = 5; // 无需创建对象即可直接访问
16

17
    Entity e1;
18
    e1.sharedX = 10; // 也可以通过对象访问，但实际上改的是同一个静态内存
19

20
    Entity::Print(); // 输出 10
21
}

经典应用：单例模式（Meyers’ Singleton）#

这是 C++ 中实现单例模式最优雅、最简洁的方式（且在 C++11 后是线程安全的）：

1
class Singleton {
2
public:
3
    // 返回引用，避免拷贝
4
    static Singleton& Get() {
5
        // 第一次调用 Get() 时，instance 被创建
6
        // 以后再调用，直接返回存活在静态内存区的 instance
7
        static Singleton instance;
8
        return instance;
9
    }
10

11
    void Hello() {}
12
};
13

14
int main() {
15
    // 使用方式
16
    Singleton::Get().Hello();
17
}

这种写法避免了全局变量的初始化顺序问题，实现了完美的“懒加载”（Lazy Initialization）。

4.1 本质#

this 是一个隐藏的参数，存在于所有非静态成员函数中。它是一个指针，指向当前调用该方法的对象实例。

4.2 编译器眼中的代码#

你以为你写的：

1
void Entity::Print() {
2
    std::cout << x << std::endl;
3
}

编译器实际处理的（伪代码）：

1
void Entity_Print(Entity* this) {
2
    std::cout << this->x << std::endl;
3
}

4.3 常见用途#

1. 区分同名参数： 当成员变量名和参数名冲突时，使用 this 来明确指代成员变量。

   1
   void SetX(int x) {
   2
       this->x = x; // 将参数 x 赋值给成员变量 x
   3
   }
   

2. 链式调用（Method Chaining）： 返回 *this（即对象的引用），可以让方法连续调用。

   1
   class Builder {
   2
   public:
   3
       Builder& SetWidth(int w) { width = w; return *this; }
   4
       Builder& SetHeight(int h) { height = h; return *this; }
   5
   private:
   6
       int width, height;
   7
   };
   8
   
   9
   // 调用：
   10
   Builder b;
   11
   b.SetWidth(100).SetHeight(200);
   

5.1 本质区别#

• 指针：是一个变量，存储的是内存地址。可以为空（nullptr），可以重新赋值指向其他对象。
• 引用：是对象的别名。必须初始化，且一旦绑定不可更改。

5.2 使用场景对比#

5.3 常见误区#

• 野指针：指针未初始化或指向已释放的内存。务必初始化指针（如 nullptr）并在 delete 后置空。
• 悬空引用：返回局部变量的引用。函数结束时局部变量销毁，引用指向非法内存。

5.4 性能考量#

在传递大型对象（如自定义类）时，优先使用 const 引用 (const MyClass&)，避免不必要的拷贝开销，同时保证数据安全。