构造/析构/赋值运算理解

一、正常情况下

以下函数会自动生成：

#include <iostream>using namespace std;class Empty {public:Empty() {}                  // 默认构造函数Empty(const Empty& rhs) {}  // 拷贝构造函数 rhs是右操作符缩写~Empty() {}                 // 析构函数// 拷贝赋值运算符// 第一个&：返回类型是引用，第二个&：参数是一个常量对象的引用Empty& operator=(const Empty& rhs) {// this是一个隐含的指针参数，存在于每一个非静态成员函数中// 当你调用一个对象的成员函数的时，编译器会自动把该对象的地址传入thisif(this!=&rhs){ // 拷贝成员变量}return *this;}  int x;static int count; // 静态成员变量（属于类，全局唯一）// 非静态成员函数的本质，其实是一个普通函数，只是多了一个隐式的“this 指针”参数。// 非静态成员函数，属于对象void show(){ // 等于 void show(Empty* this)cout<<"x="<<x<<endl;}// 静态成员函数，属于类本身// 静态函数属于类，不属于对象，调用时没有this，因此不能访问对象成员// 静态成员函数可以访问静态变量static void info(){cout<<"count="<<count<<endl;}
};int main(){Empty a; // 创建一个对象a.x =10;a.show();   // 编译器幕后会改写为 Empty::show(&a);而this==&areturn 0;
}

二、若不想使用编译器自动生成的函数，就该明确拒绝（Effective C++ 06）

下面的例子是编译可以通过，但是可能报错的情况：

#include <iostream>using namespace std;class File {public:File(const std::string& filename) {cout << "打开文件: " << filename << endl;}~File() { cout << "关闭文件\n"; }// 没有禁拷贝！
};int main() {File f1("data.txt");File f2 = f1;  // ✅ 编译能过，但逻辑错误！
}
// 可以编译通过
// 编译器会自动生成一个“浅拷贝”构造函数；
// f1 和 f2 都指向同一个文件；
// 当 main() 结束时，~File() 会执行两次；
// 💥 程序可能崩溃（重复关闭同一文件描述符）。

可以明确拒绝默认构造：

#include <iostream>using namespace std;class File { // File类用来管理文件的打开与关闭
public:File(const std::string& filename) { open(filename); } // 构造函数：当创建FILE对象时，会自动打开~File() { close(); } //析构函数File(const File&) = delete;             // ❌ 禁止拷贝构造File& operator=(const File&) = delete;  // ❌ 禁止赋值
private:void open(const std::string& filename);void close();
};int main(){File f1("data.txt");// File f2 = f1;   // ❌ 编译器会自动调用拷贝构造函数！return 0;
}

明确拒绝的含义：
不要让编译器帮你做不安全的事情。

如果你知道这个类不应该被拷贝/赋值。

就要用=delete明确告诉编译器禁止生成。

三、为多态基类声明virtual析构函数（Effective C++ 07）

如果一个类打算被当作基类使用（尤其是通过基类指针删除派生类对象），
那它的析构函数就必须是 virtual 的。

问题示例：

#include <iostream>using namespace std;class Base {public:~Base() { cout << "Base::~Base()\n"; }
};class Derived : public Base {public:~Derived() { cout << "Derived::~Derived()\n"; }
};int main() {Base* p = new Derived(); // p的静态类型是Base*// 调用delete p;时，编译器只知道它是个Base*// 没有virtual，就不会做动态绑定//所以只调用Base::~Basedelete p;  // ❌ 问题点！
}// Derived 的析构函数 没有被调用！
// Derived 中的资源（比如动态内存、文件、锁等）不会被释放！
// 导致资源泄漏甚至未定义行为。

当析构函数不是 virtual 时，delete p; 只会调用指针静态类型的析构函数。

正确写法：

#include <iostream>using namespace std;class Base {public:virtual ~Base() { cout << "Base::~Base()\n"; }
};class Derived : public Base {public:~Derived() { cout << "Derived::~Derived()\n"; }
};int main() {Base* p = new Derived();delete p;  // ✅ 正确释放
}

如果你的类打算被继承，会通过基类指针或引用操作对象，尤其通过delete basePtr;删除对象，就必须加virtual.

四、别让异常逃离析构函数（Effective C++ 08）

因为在 C++ 中，如果析构函数在栈展开（stack unwinding)过程中抛出异常，
会导致 程序直接终止（std::terminate()）。

栈展开：当异常被抛出后，程序未来找到合适的catch块，会依次退出当前函数调用栈中的函数，并在退出的过程中自动调用已构造对象的析构函数。

简单说，就是从抛出点开始，一层层弹出函数调用栈，清理已创建的局部对象。

错误示例：

#include <iostream>
using namespace std;class Test {public:~Test() { throw runtime_error("析构函数异常！"); } // 3析构函数又抛出了第二个异常
};void func() {Test t;  // 局部对象throw runtime_error("函数内部异常！");  // 2抛出异常，程序开始栈展开，准备析构局部对象t
}int main() {try {func();  // 1} catch (const exception& e) {cout << "捕获异常：" << e.what() << endl;}
}

C++ 语言规定：

如果一个异常在栈展开期间再次抛出，程序必须调用 std::terminate()。

原因：

• 栈展开期间系统已经在处理一个异常；

• 若又有另一个异常冒出，编译器无法同时处理两个异常；

• 为保证系统稳定，只能直接终止程序。

#include <iostream>
using namespace std;class Test {public:~Test() {try {danger();  // 可能抛出异常} catch (const exception& e) {cerr << "析构函数捕获异常" << e.what() << endl;}}private:void danger() { throw runtime_error("文件关闭失败"); }// 如果上层函数没有 catch，异常会继续向上层传播，这样可以不让它往上跑
};void func() {Test t;  // 局部对象throw runtime_error("函数内部异常！");  // 2抛出异常，程序开始栈展开，准备析构局部对象t
}int main() {try {func();  // 1} catch (const exception& e) {cout << "捕获异常：" << e.what() << endl;}
}

五、绝不在构造和析构过程中调用virtual函数（Effective C++ 09）

因为在构造和析构期间，对象的多态性还没”完全建立”或已经“失效”。

调用虚函数不会发生多态，而只会调用当前类版本的函数。

c++的对象在构造时是分阶段构造的：

1️⃣ 构造 Base 部分（调用 Base::Base()）
2️⃣ 再构造 Derived 部分（调用 Derived::Derived()）

也就是说，当执行 Base() 构造函数时，
整个对象的“有效类型”其实就是 Base。

错误示例:

正确示例：

如果非要在构造过程中自动调用怎么办？

用工厂函数或静态创建函数。

工厂函数:

把对象的创建过程封装起来，而不是直接在外部用 new 或构造函数创建对象。

六、令operator=返回一个reference to *this（Effective C++ 10）

“让赋值运算符函数返回当前对象本身的引用。”

因为我们希望赋值操作能连续使用。

这样可以支持连锁赋值，就像内建类型（int,double）那样。

a = b = c;

编译器会当成：

a.operator=( b.operator=(c) );

要想这样写能成立，
b.operator=(c) 必须返回 b 自己（的引用），
这样外层的 a.operator=(...) 才能继续执行。

错误写法：

class A {
public:A operator=(const A& rhs) {   // 返回一个“副本”，注意：返回类型是 A（值），不是 A&// 拷贝数据...return *this;             // 返回一个临时对象}
};

这样会发生：

• (b = c) 返回了一个临时副本；

• 外层 a = (b = c) 就变成了 a = 临时对象；

• 临时对象马上销毁；

• 效率差，行为不符合期望。

解释：多一次拷贝，效率变差

正确写法：

class A {
public:A& operator=(const A& rhs) {  // 返回引用if (this != &rhs) {// 拷贝数据}return *this;             // 返回自己}
};

上面这份代码就不会产生一个临时对象。

七、在operator=中处理”自我赋值“（Effective C++ 11）

a=a ；

a = f(); // f() 恰好返回 a 的引用
这个就是自我赋值，如果没有处理好，就可能在赋值过程中把自己给毁掉了。

加一条：检查自我赋值就可以了。

八、复制对象时勿忘其每一个成分（Effective C++ 12）

当你为一个类写拷贝构造函数或者拷贝赋值运算符时，一定要记得复制对象的所有成员和所有基类部分。

错误示范：

正确示范：

一旦定义了自己的拷贝构造函数或operator=，编译器就不会再自动生成默认版本，而默认版本里才会包含”基类+成员“的完整拷贝逻辑。

所以，当你手动定义了，就必须接住这个责任。