第十章：对象和类 | C++ Primer Plus 重点带看

类实例的成员共享与独立

类的所有实例共享同一份成员函数代码，但各自拥有独立的数据成员（注意：静态数据成员是共享的，只有一份）。成员函数通过隐式 this 指针区分调用对象。静态成员（数据和函数）被所有实例共享。

class Person {
private:
    string name;
    int age;
public:
    void setInfo(string n, int a) {
        name = n;
        age = a;
    }
    void display() {
        cout << name << ": " << age << endl;
    }
};
// 编译器实现：
// void Person::display(Person* this) {
//     cout << this->name << ": " << this->age << endl;
// }

Person p1, p2, p3;  // 三个对象

// 各自独立的数据
p1.setInfo("Alice", 20);
p2.setInfo("Bob", 25);
p3.setInfo("Carol", 30);

// 共享同一份成员函数代码
p1.display();  // Alice: 20，会传入 this = &p1，编译器转换为：Person::display(&p1);
p2.display();  // Bob: 25，会传入 this = &p2，编译器转换为：Person::display(&p2);
p3.display();  // Carol: 30，会传入 this = &p3，编译器转换为：Person::display(&p3);

┌────────────────────────────────────────────┐
│ 成员函数（代码段，只有一份）                 │
│                                            │
│   void setInfo(string n, int a) { ... }    │
│   void display() { ... }                   │
│                                            │
└────────────────────────────────────────────┘
                    ▲
        ┌───────────┼───────────┐
        │           │           │
        ▼           ▼           ▼
   ┌─────────┐ ┌─────────┐ ┌─────────┐
   │ p1      │ │ p2      │ │ p3      │
   │ name    │ │ name    │ │ name    │
   │ age     │ │ age     │ │ age     │
   └─────────┘ └─────────┘ └─────────┘
      栈/堆       栈/堆      栈/堆

   各自独立的    各自独立的    各自独立的
   数据成员      数据成员      数据成员

构造函数特征

构造函数没有返回类型（连 void 都不是），名字与类名相同，可重载，可有参数和默认参数。构造函数不能是 const、static 或 virtual，因为构造时对象类型尚未完全确定，需要修改对象状态。

class Person {
private:
    string name;
public:
    // 名字与类名相同
    Person() : name("default") { }              // 默认构造函数
    Person(string n) : name(n) { }              // 重载
    Person(const Person& other) : name(other.name) { }  // 拷贝构造
    Person(Person&& other) noexcept : name(std::move(other.name)) { }  // 移动构造
    
    // ✗ 不能是 const（构造函数需要修改对象）
    // Person() const { }
    
    // ✗ 不能是 static（构造函数需要 this 指针）
    // static Person() { }
    
    // ✗ 不能是 virtual（构造时对象类型尚未完全确定，虚函数需要对象存在（需要 vptr），但对象还没构造好）
    // virtual Person() { }
};

默认构造函数

仅当没有定义任何构造函数时，编译器才提供默认构造函数。

自定义默认构造函数有两种方式：无参构造函数、全默认参数构造函数。两者不能同时存在，否则调用时产生二义性。

可用 = default 显式要求编译器提供。

析构函数

析构函数无参数、无返回类型、不可重载。

多态场景下基类析构函数必须是 virtual，否则派生类析构函数不会被调用，导致资源泄漏。

析构顺序与构造顺序相反。除非使用定位 new，否则不要显式调用析构函数。

类私有成员访问的方式

1、类的成员函数：任何成员函数（公有、私有、保护）都可以访问私有成员。

class Person {
private:
    string name;
    
public:
    string getName() { return name; }      // 公有成员函数访问
    void setName(string n) { name = n; }
    
private:
    void secretMethod() { cout << name; }  // 私有成员函数也可访问
};

2、友元函数：

class Person {
private:
    string name;
    friend void showSecret(const Person& p);  // 友元声明
};

void showSecret(const Person& p) {
    cout << p.name << endl;  // 可访问私有成员
}

3、友元类：

class Person {
private:
    string name;
    friend class Spy;  // Spy 的所有成员函数都可访问
};

class Spy {
public:
    void steal(const Person& p) {
        cout << p.name << endl;  // 可访问私有成员
    }
};

注意：友元声明可放在类定义的任意位置（public/private/protected），效果相同。因为友元不是类成员，不受访问控制符限制。通常习惯放在类定义的开头或结尾，以示区分。

类的默认访问控制

class 的默认成员访问和继承访问是私有。（struct 的默认访问类型是公有，这是类和结构唯一的区别，只是人们习惯把结构限制为只表示纯粹数据的对象；类习惯用于封装数据和行为的对象）

this 指针

this 指针指向调用成员函数的对象，是非 const 指针（className* const，const 成员函数中为 const 指针：const ClassName* const）。

// 源代码
void Person::setName(string name) {
    this->name = name;
}

// 编译器视角
void Person_setName(Person* this, string name) {
    this->name = name;
}

// 调用转换
p1.setName("Alice");  // Person_setName(&p1, "Alice");

用途包括：区分同名成员与参数、链式调用（返回 *this）、自赋值检测、传递当前对象指针。

class Person {
private:
    string name;
public:
    // 1. 区分成员与参数同名
    void setName(string name) {
        this->name = name;
    }
    
    // 2. 返回当前对象引用（链式调用）
    Person& setName(string name) {
        this->name = name;
        return *this;
    }
    
    // 3. 自赋值检测
    Person& operator=(const Person& other) {
        if (this == &other) return *this;
        name = other.name;
        return *this;
    }
    
    // 4. 传递当前对象
    void registerSelf() {
        someManager.registerPerson(this);
    }
};

this 不能被修改，为空时调用成员函数是未定义行为。

Person* p = nullptr;
p->setName("Alice");  // 未定义行为！

// 如果 setName 不访问任何成员，可能"碰巧"不崩溃
// 但仍然是未定义行为，绝不能依赖

const 成员函数

1、const 成员函数不能修改对象成员（mutable 除外），其 this 指针为 const 类型。

class Person {
public:
    void display() const;
    void setAge(int a);
};

// 编译器视角：
// void display(const Person* this);    // this 是 const 指针
// void setAge(Person* this);           // this 是非 const 指针

2、const 对象只能调用 const 成员函数。const 成员函数可与非 const 版本构成重载。

class Person {
private:
    string name;
    int age;
public:
    void display() const {  // const 成员函数
        cout << name << ": " << age << endl;  // ✓ 可读取
        // name = "new";    // ✗ 不能修改成员
        // age = 0;         // ✗ 不能修改成员
    }
    
    void setAge(int a) {
        age = a;  // ✓ 非const函数可以修改
    }
};
Person p1;
p1.display();  // ✓ 正常对象可调用 const 函数
p1.setAge(20); // ✓ 正常对象可调用非 const 函数

const Person p2("Alice", 25);
p2.display();   // ✓ const 对象可调用 const 函数
// p2.setAge(30);  // ✗ const 对象不能调用非 const 函数

3、mutable 关键字允许在 const 函数中修改特定成员。

class Counter {
private:
    mutable int count;  // mutable 成员
    string name;
public:
    void display() const {
        count++;         // ✓ mutable 成员可修改
        // name = "x";   // ✗ 非 mutable 成员不可修改
    }
};

inline 关键字的现代含义

现代 C++ 中，inline 主要是链接指令，允许多个翻译单元定义同一函数/变量，链接器合并为同一实体。

内联展开的优化决策由编译器独立决定，inline 关键字只是建议，编译器可忽略。没有 inline 的简短函数也可能被自动内联展开。

// 有 inline，不一定展开
inline void hugeFunction() {
    // 1000行代码...
    // 编译器：太长了，不展开
}

// 没有 inline，也可能展开
void tinyFunction() {
    return x + 1;
    // 编译器：简单，自动内联展开
}

类内定义成员函数与内联

类内定义的成员函数隐式内联，但 inline 只是建议，编译器决定是否真正展开。简短函数通常被内联展开，复杂函数可能只生成函数调用。

内联可消除调用开销，但过度内联会导致代码膨胀。类外定义需显式加 inline（注意：inline 定义要放在头文件，否则放对应 cpp 里可能导不出符号，导致链接错误）。

inline 函数中的 static 变量

C++11 起标准明确要求，inline 函数中的静态局部变量在整个程序中只有一个实例，所有翻译单元共享。这与 static 函数不同——后者每个翻译单元有独立的函数副本和静态变量。

// header.h
inline void func() {
    static int count = 0;
    cout << ++count << endl;
}

// a.cpp
#include "header.h"
void testA() { func(); }

// b.cpp
#include "header.h"
void testB() { func(); }

// main.cpp
#include "header.h"
int main() {
    func();    // 输出 1
    testA();   // 输出 2
    testB();   // 输出 3
}