C++异常与智能指针，资源泄露

一.异常的抛出和捕获

1. 抛出：通过抛出(throw)⼀个对象来引发⼀个异常（throw执行时，throw后面的语句将不再被执行）
2. 捕获：用catch来捕获（catch可能是同⼀函数中的⼀个局部的catch，也可能是调用链中另⼀个函数中的catch，控制权从throw位置转移到了catch位置）

抛出异常对象后，会生成⼀个异常对象的拷贝，因为抛出的异常对象可能是⼀个局部对象，所以会 生成⼀个拷贝对象，这个拷贝的对象会在catch子句后销毁。（这里的处理类似于函数的传值返 回）

//基本结构
try {
    // 可能抛出异常的代码
    if (错误条件) {
        throw 异常值; // 抛出异常
    }
} catch (异常类型 变量名) {
    // 处理异常的代码
}

简单除法异常示例

#include <iostream>
using namespace std;

// 除法函数，当除数为0时抛出异常
double divide(double a, double b) {
    if (b == 0) {
        // 抛出字符串类型的异常
        throw "除数不能为0";
    }
    return a / b;
}

int main() {
    double x = 10, y = 0, result;
    
    try {
        result = divide(x, y);
        cout << "结果: " << result << endl; // 如果抛出异常，这行不会执行
    } catch (const char* errorMsg) { // 捕获字符串类型的异常
        cout << "错误: " << errorMsg << endl;
    }
    
    cout << "程序继续执行..." << endl;
    return 0;
}

在抛出异常之后，程序暂停当前函数的执行，开始寻找与之匹配的catch子句，首先检查throw本⾝是否在try块内部，如果在则查找匹配的catch语句，如果有匹配的，则跳到catch的地方进行处理。如果当前函数中没有try/catch子句，或者有try/catch子句但是类型不匹配，则退出当前函数，继续 在外层调用函数链中查找，上述查找的catch过程被称为栈展开 。

 栈展开简单示例

#include <iostream>
using namespace std;

void func3() {
    cout << "在func3中抛出异常" << endl;
    throw "发生错误";
}

void func2() {
    cout << "调用func3" << endl;
    func3(); // 调用可能抛出异常的函数
    cout << "func3调用后（不会执行）" << endl;
}

void func1() {
    cout << "调用func2" << endl;
    func2(); // 调用可能抛出异常的函数
    cout << "func2调用后（不会执行）" << endl;
}

int main() {
    try {
        cout << "调用func1" << endl;
        func1();
    } catch (const char* msg) {
        cout << "在main中捕获异常: " << msg << endl;
    }
    return 0;
}
//输出结果
//调用func1
//调用func2
//调用func3
//在func3中抛出异常
//在main中捕获异常: 发生错误

1.1异常类型

C++ 可以抛出任何类型的异常，包括：

• 基本数据类型（int, double 等）
• 字符串
• 自定义类 / 结构体

自定义异常类：

#include <iostream>
#include <string>
using namespace std;

// 自定义异常类
class DivideByZeroException {
private:
    string message;
public:
    DivideByZeroException(string msg) : message(msg) {}
    
    // 获取错误信息
    string getMessage() const {
        return message;
    }
};

double divide(double a, double b) {
    if (b == 0) {
        // 抛出自定义异常
        throw DivideByZeroException("除数不能为0");
    }
    return a / b;
}

int main() {
    try {
        cout << divide(10, 2) << endl;  // 正常执行
        cout << divide(10, 0) << endl;  // 抛出异常
    } catch (const DivideByZeroException& e) {  // 捕获自定义异常
        cout << "捕获到异常: " << e.getMessage() << endl;
    }
    return 0;
}

二.资源泄露

2.1 RAII：资源获取即初始化

RAII（Resource Acquisition Is Initialization）的核心思想是：将资源的生命周期与对象的生命周期绑定。具体来说：

1. 资源在对象的构造函数中获取（申请）；
2. 资源在对象的析构函数中释放（归还）；
3. 当对象超出作用域时，编译器会自动调用析构函数，从而确保资源被释放。

在使用手动管理文件资源很容易出现忘记关闭文件而导致文件泄露。

出现这种情况可以使用RAII的思想

// RAII方式：用对象管理文件资源（安全）
#include <fstream>
#include <stdexcept>
using namespace std;

// 定义一个RAII类，绑定文件资源的生命周期
class FileHandler {
private:
    ofstream file; // 资源（文件句柄）作为对象的成员
public:
    // 构造函数：获取资源（打开文件）
    FileHandler(const string& filename) {
        file.open(filename);
        if (!file.is_open()) {
            throw runtime_error("文件打开失败"); // 打开失败则抛异常
        }
    }
    
    // 析构函数：释放资源（关闭文件）
    ~FileHandler() {
        if (file.is_open()) {
            file.close(); // 无论如何，对象销毁时一定会关闭文件
        }
    }
    
    // 提供操作文件的接口
    ofstream& get_file() {
        return file;
    }
};

void write_to_file() {
    // 1. 创建对象时，自动获取资源（调用构造函数打开文件）
    FileHandler handler("data.txt"); 
    
    // 2. 使用资源
    handler.get_file() << "hello RAII"; 
    
    // 3. 函数结束时，handler对象超出作用域，自动调用析构函数释放资源（关闭文件）
    // 即使中间有return或异常，析构函数仍会被调用
}

int main() {
    try {
        write_to_file();
    } catch (const exception& e) {
        // 处理异常
    }
    return 0;
}

2.2. 智能指针：RAII 在内存管理中的应用 

智能指针是 C++ 标准库提供的模板类，其本质是用 RAII 思想管理动态内存的对象：

1. 智能指针在构造时获取内存（接收new的返回值）；
2. 在析构时自动释放内存（调用delete）；
3. 行为类似指针（可通过*和->访问所指对象

2.2.1 auto_ptr： 

拷贝时把被拷贝对象的资源的管理权转移给拷贝对象，导致被拷贝对象悬空。

2.2.2unique_ptr： 

unique_ptr表示对内存的独占所有权（同一时间只有一个unique_ptr指向该内存），适用于资源只能被一个对象使用的场景。（不支持拷贝，只支持移动）

2.2.3  shared_ptr：

shared_ptr通过引用计数（析构多次）实现内存的共享所有权：多个shared_ptr可指向同一内存，当最后一个shared_ptr销毁时，才释放内存。

#include <iostream>
#include <memory>
using namespace std;

int main() {
    // 创建shared_ptr，引用计数初始化为1
    shared_ptr<int> sptr1 = make_shared<int>(20); 
    cout << "引用计数：" << sptr1.use_count() << endl; // 输出：1
    
    // 复制sptr1，引用计数变为2（共享所有权）
    shared_ptr<int> sptr2 = sptr1; 
    cout << "引用计数：" << sptr1.use_count() << endl; // 输出：2
    
    // sptr2超出作用域，引用计数减为1
    {
        shared_ptr<int> sptr3 = sptr1;
        cout << "引用计数：" << sptr1.use_count() << endl; // 输出：3
    }
    cout << "引用计数：" << sptr1.use_count() << endl; // 输出：2
    
    // 最后sptr1和sptr2销毁，引用计数变为0，内存被释放
    return 0;
}

定制删除器 

shared_ptr默认的释放逻辑是调用delete，但以下场景需要自定义删除行为：

1. 管理动态数组（需要用delete[]而不是delete）
2. 释放非内存资源（如文件指针、网络套接字）
3. 执行额外的清理操作（如日志记录、状态重置）

删除器可以是：函数指针 ， 函数对象（ functor ），Lambda 表达式（C++11 及以上）
当shared_ptr的引用计数变为 0 时，会自动调用定制的删除器来释放资源。 

#include <iostream>
#include <memory>
using namespace std;

int main() {
    // 方式1：使用函数指针作为删除器
    auto array_deleter = [](int* ptr) {
        cout << "释放动态数组" << endl;
        delete[] ptr; // 注意使用delete[]
    };
    
    // 创建shared_ptr时指定删除器
    shared_ptr<int> arr_ptr(new int[5]{1,2,3,4,5}, array_deleter);
    
    // 使用数组（需注意shared_ptr不直接支持[]操作，需手动获取原始指针）
    for (int i = 0; i < 5; ++i) {
        cout << arr_ptr.get()[i] << " "; // get()获取原始指针
    }
    cout << endl;
    
    // 当arr_ptr销毁时，会自动调用array_deleter，用delete[]释放数组
    return 0;
}

定制删除器相关代码 

#include<iostream>
#include<assert.h>
#include<functional>
using namespace std;
namespace happy
{
	template<class T>
	class shared_ptr
	{
	public :
		shared_ptr(T*ptr=nullptr)
			:_ptr(ptr),
			pcount(new int(1))
		{}
		shared_ptr(const shared_ptr<T>& sp)
			:_ptr(sp._ptr),pcount(sp.pcount)
		{
			(*pcount)++;
		}
		template<class D>
		shared_ptr(T*ptr,D* del)
			:_ptr(ptr),
			pcount(new int (1)),
			_del(del)
		{}
		void release()
		{
			if (--(*pcount) == 0)
			{
				//定制删除器
				_del(_ptr);
				//delete _ptr;
				delete pcount;
			}
		}
		~shared_ptr()
		{
			release();
		}
		shared_ptr<T>& operator=(const shared_ptr<T>& sp)
		{
			//处理自己给自己赋值情况
			if (_ptr != sp._ptr)
			{
				release();
				_ptr = sp._ptr;
				pcount = sp.pcount;
				return *this;
			}
		}
		//像指针一样使用
		T& operator*()
		{
			return *_ptr;
		}
		T* operator->()
		{
			return &_ptr;
		}
	private:
		T* _ptr;
		int* pcount;
		function<void(T*)> _del = [](T* ptr) {delete ptr; };
	};
}
int main()
{
	happy::shared_ptr<int> sp1(new int(1));
	happy::shared_ptr<int> sp2(sp1);
	happy::shared_ptr<int> sp3(new int(2));
	sp1 = sp3;

	sp1 = sp1;
	sp1 = sp2;
	return 0;
}

make_shared： 

shared_ptr 提供了两种主要方式创建实例：一种是通过已有的资源指针构造，另一种是使用 make_shared 直接通过资源的初始化值来构造。

两种构造的对比

#include <memory>
using namespace std;

int main() {
    // 先手动用new创建对象，再传给shared_ptr
    shared_ptr<int> ptr(new int(42));

   // 直接传入初始化值，make_shared内部会自动分配内存并初始化
    shared_ptr<int> ptr = make_shared<int>(42);
    return 0;
}

make_shared的优势 

1：更高的效率
make_shared 会一次性分配内存（同时存储对象和 shared_ptr 的控制块），而 new + shared_ptr 构造需要两次内存分配（一次给对象，一次给控制块）。
2：更安全（避免内存泄漏风险）
考虑以下场景，make_shared 能避免潜在的内存泄漏：

#include <memory>
#include <iostream>
using namespace std;

void process(shared_ptr<int> ptr, int value) {
    // 处理逻辑
}

int main() {
    // 危险：可能导致内存泄漏
    process(shared_ptr<int>(new int(42)), some_function()); 
    // 原因：C++允许先执行new int(42)，再调用some_function()
    // 如果some_function()抛出异常，shared_ptr还未构造，new分配的内存会泄漏

    // 安全：make_shared能避免这种情况
    process(make_shared<int>(42), some_function());
    // 因为make_shared是一个函数调用，要么完全成功（内存分配+构造），要么完全失败（不分配内存）
    return 0;
}

shared_ptr循环引用问题 

循环引用指的是两个或多个shared_ptr互相持有对方的引用，形成一个闭环，使得引用计数始终无法归零，从而资源无法释放。

例子：

#include <iostream>
#include <memory>
using namespace std;

class Child; // 前向声明

class Parent {
public:
    // 父对象持有子对象的shared_ptr
    shared_ptr<Child> child_ptr;
    
    Parent() { cout << "Parent构造" << endl; }
    ~Parent() { cout << "Parent析构" << endl; } // 析构函数不会被调用
};

class Child {
public:
    // 子对象持有父对象的shared_ptr
    shared_ptr<Parent> parent_ptr;
    
    Child() { cout << "Child构造" << endl; }
    ~Child() { cout << "Child析构" << endl; } // 析构函数不会被调用
};

int main() {
    // 创建父对象和子对象
    shared_ptr<Parent> parent = make_shared<Parent>();
    shared_ptr<Child> child = make_shared<Child>();
    
    // 互相引用：形成循环
    parent->child_ptr = child;  // parent的引用计数仍为1，child的引用计数变为2
    child->parent_ptr = parent; // child的引用计数仍为2，parent的引用计数变为2
    
    // 函数结束时，parent和child的引用计数各减1（变为1）
    // 但由于互相持有，引用计数始终不为0，析构函数不会被调用
    return 0;
}

 解决方法：使用weak_ptr

weak_ptr是一种 "弱引用" 智能指针，它持有对象的引用但不增加引用计数，可以用来观察对象但不影响其生命周期。用weak_ptr替代循环引用中的一方的shared_ptr，即可打破循环。

2.2.4 weak_ptr ：

weak_ptr的产生本质是要解决shared_ptr 的⼀个循环引用导致内存泄漏的问题

#include <iostream>
#include <memory>
using namespace std;

class Child;

class Parent {
public:
    shared_ptr<Child> child_ptr; // 父对象仍用shared_ptr持有子对象
    
    Parent() { cout << "Parent构造" << endl; }
    ~Parent() { cout << "Parent析构" << endl; }
};

class Child {
public:
    weak_ptr<Parent> parent_ptr; // 子对象用weak_ptr持有父对象（关键修改）
    
    Child() { cout << "Child构造" << endl; }
    ~Child() { cout << "Child析构" << endl; }
};

int main() {
    shared_ptr<Parent> parent = make_shared<Parent>();
    shared_ptr<Child> child = make_shared<Child>();
    
    parent->child_ptr = child;  // child引用计数变为2
    child->parent_ptr = parent; // parent引用计数仍为1（weak_ptr不增加计数）
    
    // 函数结束时：
    // 1. child的引用计数减1（变为1）
    // 2. parent的引用计数减1（变为0，Parent对象被销毁）
    // 3. Parent销毁后，其child_ptr被释放，child的引用计数减1（变为0，Child对象被销毁）
    return 0;
}

weak_ptr不能直接访问对象，需先通过lock()方法转换为shared_ptr（确保对象未被销毁）：

// 在Child类中访问Parent对象
void Child::access_parent() {
    // lock()返回shared_ptr：若对象存在则非空，否则为空
    shared_ptr<Parent> temp = parent_ptr.lock();
    if (temp) {
        // 安全访问父对象
    } else {
        // 父对象已被销毁
    }
}

三.资源泄露 

内存泄漏指因为疏忽或错误造成程序未能释放已经不再使用的内存，⼀般是忘记释放或者发生异常释放程序未能执行导致的。内存泄漏并不是指内存在物理上的消失，而是应用程序分配某段内存后，因为设计错误，失去了对该段内存的控制，因而造成了内存的浪费。