C++ 内存安全双保险：异常处理 + 智能指针，彻底跟内存泄漏说 “再见”

#include <cassert>
void errorC() {
	// 1. 错误码
	int* arr = (int*)malloc(4 * sizeof(int));
	if (arr == NULL) {
		perror("malloc error:");
		return;
	}

	// 2. assert
	int num = 0;
	assert(num != 0);

}

void division(double a, double b) {
	if (b == 0)
		throw logic_error("分母为零！\n");
	cout << "结果: " << a / b << endl;
}
int main() {
	try {
		division(10, 0);
	}
	catch(const logic_error& e){
		cout << "错误：" << e.what() << endl;
	}

	return 0;
}

void func1() {
	throw "1111111";
}

int main() {
	try {
		func1();
	}
	catch (const char* errmsg) {
		cout << "捕获到的异常:" << errmsg << endl;
	}
}

void func() {
	throw out_of_range("越界！");
}

void Func() {
	try {
		func();
	}
	catch (const out_of_range& e) {
		cout << "Func 捕获到的异常:" << e.what() << endl;
	}
}

int main() {
	try {
		Func();
	}
	catch(const exception& e){
		cout << "main 捕获到的异常：" << e.what() << endl;
	}

	return 0;
}

void func() {
	throw out_of_range("越界！");
}
int main() {
	try {
		func();
	}
	catch (const exception& e) {
		cout << "exception 捕获:" << e.what() << endl;
	}
	return 0;
}

void func() {
	throw 42;  // 抛出整数类型异常
}

int main() {
	try {
		func();
	}
	catch (...) {  // 捕获所有异常
		std::cout << "Caught some exception" << std::endl;
	}
	return 0;
}

// 栈展开
void func1() {
    throw out_of_range("Out of range error in func1");  // 异常在 func1 中抛出
}

void func2() {
    try {
        func1();  // 异常从 func1 传递到 func2
    }
    catch (const out_of_range& e) {
        cout << "Caught in func2: " << e.what() << endl;  // func2 捕获异常
        throw;  // 重新抛出异常
    }
}

int main() {
    try {
        func2();  // func2 捕获异常并重新抛出
    }
    catch (const exception& e) {
        cout << "Caught in main: " << e.what() << endl;  // main 捕获异常并处理
    }
    return 0;
}

1. main() 调用 func2()
|
2. func2() 调用 func1()
|
3. func1() 中抛出 out_of_range 异常
|
4. 异常从 func1() 向 func2() 传播，func2() 捕获该异常
|
5. 如果 func2() 中没有捕获异常，异常会继续传递给 main() 函数
|
6. 如果 main() 没有捕获异常，程序终止

┌──────────────┐
│    main()    │  <-- 异常会传递到 main()，如果没有捕获程序终止
└──────────────┘
       ↑
┌──────────────┐
│   func2()    │  <-- 如果 func2() 捕获异常，栈展开停止
└──────────────┘
       ↑
┌──────────────┐
│   func1()    │  <-- 异常从 func1() 抛出并传递
└──────────────┘

// 异常重新抛出
double division(double a, double b) {
	if (0 == b) {
		throw "分母为零！";
	}
	return a / b;
}

void Func() {
	// 如果发生分母为零抛出异常 但是arr还未释放
	// 所以这里捕获了异常但不处理
	// 把异常交给外界处理 捕获之后重新抛出去
	int* arr = new int[10];
	try {
		cout << division(10.1,0) << endl;
	}
	catch (...) {
		cout << "delete[]" << arr << endl;
		delete[] arr;
		throw;
	}

	cout << "delete[]" << arr << endl;
	delete[] arr;
}

int main() {

	try {
		Func();
	}
	catch (const char* errmsg) {
		cout << errmsg << endl;
	}
	return 0;
}

// 这里表示这个函数会抛出A/B/C/D中的某种类型的异常
void fun() throw(A，B，C，D);
// 这里表示这个函数只会抛出bad_alloc的异常
void* operator new (std::size_t size) throw (std::bad_alloc);
// 这里表示这个函数不会抛出异常
void* operator delete (std::size_t size, void* ptr) throw();
// C++11 中新增的noexcept，表示不会抛异常
thread() noexcept;
thread (thread&& x) noexcept;

#include <iostream>
using namespace std;

double div() {
	double a = 0, b = 0;
	cin >> a >> b;
	if (0 == b) throw "分母为零 !\0";
	return a / b;
} 

void funcCatch() {
	double* pa = new double;
	double* pb = new double;

	cout << div() << endl;

	delete pa;
	delete pb;
}

int main() {
	try {
		funcCatch();
	}
	catch(exception& e){
		cout << e.what() << endl;
	}

	return 0;
}

void funcCatch() {
	double* pa = new double;
	double* pb = new double;

	cout << div() << endl;

	delete pa;
	delete pb;
}

// 内存泄漏情况
void memoryLeak() {
	// 1. 指针未释放
	int a = 10;
	int* ptr1 = &a;

	// 2. 异常造成的资源未释放
	int* arr = new int[10];
	funcCatch();

	// 先捕获到异常 造成程序终止 arr未被释放
	delete[] arr;
}

template <class T>
class smartPtr {
private:
	T* _ptr;
public:
	smartPtr(T* ptr = nullptr)
		:_ptr(ptr)
	{
		cout << "smartPtr构造: " << _ptr << endl;
	}

	~smartPtr() {
		if (_ptr) {
			cout << "smartPtr析构: " << _ptr << endl;
			delete _ptr;
		}
	}
};

#include <iostream>
using namespace std;

template <class T>
class smartPtr {
private:
	T* _ptr;
public:
	smartPtr(T* ptr = nullptr)
		:_ptr(ptr)
	{
		cout << "smartPtr构造: " << _ptr << endl;
	}

	T& operator*() { return *_ptr; }
	T* operator->() { return _ptr; }

	~smartPtr() {
		if (_ptr) {
			cout << "smartPtr析构: " << _ptr << endl;
			delete _ptr;
		}
	}
};

struct Date {
	int year;
	int month;
	int day;

	Date() = default;
};

int main() {
	
	smartPtr<int> sp1(new int);
	*sp1 = 10;

	smartPtr<Date> spDate(new Date);
	// 语法糖： spDate->operator()->
	spDate->year = 2010;
	spDate->month = 1;
	spDate->day = 1;


	return 0;
}

// auto_ptr 管理权限转移 禁止使用！！！！
#include <iostream>
using namespace std;

namespace autoPtr {
	template <class T>
	class auto_ptr {
	private:
		T* _ptr;
	public:
		auto_ptr(T* ptr = nullptr)
			:_ptr(ptr)
		{ 
			cout << "auto_ptr构造 : " << _ptr << endl;
		}

		// *this <- other other管理权给*this
		auto_ptr(const auto_ptr<T>& other) 
			:_ptr(other._ptr)
		{
			other._ptr = nullptr;
		}

		auto_ptr& operator=(auto_ptr<T>& other) {
			if (this != &other) {
				// 先释放自己的资源
				if (_ptr) {
					delete _ptr;
				}
				// 拿来别人的资源
				_ptr = other._ptr;
				other._ptr = nullptr;
			}
			return *this;
		}

		T& operator*() { return *_ptr; }
		T* operator->() { return _ptr; }

		~auto_ptr() {
			if (_ptr) {
				cout << "~auto_ptr() : " << _ptr << endl;
				delete _ptr;
			}
		}
	};

	struct Date {
		int year;
		int month;
		int day;

		Date() = default;
	};
}

int main() {

	autoPtr::auto_ptr<autoPtr::Date> spDate(new autoPtr::Date);
	spDate->year = 2010;
	spDate->month = 1;
	spDate->day = 1;

	autoPtr::auto_ptr<autoPtr::Date> cpDate(new autoPtr::Date);

	cpDate = spDate;

	return 0;
}

/**** uniquePtr.h ****/
#pragma once
namespace uniquePtr {
	template <class T>
	class unique_ptr {
	private:
		T* _ptr;
	public:
		unique_ptr(T* ptr = nullptr)
			:_ptr(ptr)
		{
			cout << "unique_ptr构造: " << _ptr << endl;
		}

		~unique_ptr() {
			if (_ptr) {
				cout << "unique_ptr析构: " << _ptr << endl;
			}
		}
		// 简单粗暴 禁止拷贝
		unique_ptr(const unique_ptr<T>& other) = delete;
		unique_ptr& operator=(const unique_ptr<T>& other) = delete;

		T& operator*() { return *_ptr; }
		T* operator->() { return _ptr; }
	};

	struct Date {
		int year;
		int month;
		int day;

		Date() = default;
	};
}

/**** test.cpp ****/
#include <iostream>
using namespace std;
#include "uniquePtr.h"

int main() {
	uniquePtr::unique_ptr<uniquePtr::Date> upDate(new uniquePtr::Date);

	upDate->day = 0;
	upDate->month = 0;
	upDate->year = 0;

	//  error C2280: “uniquePtr::unique_ptr<uniquePtr::Date>::unique_ptr(const uniquePtr::unique_ptr<uniquePtr::Date> &)”: 
	// 尝试引用已删除的函数
	// uniquePtr::unique_ptr<uniquePtr::Date> cpDate(upDate);

	return 0;
}

#pragma once
#include<functional>

namespace sharedPtr {
    template <class T>
    class shared_ptr {
    private:
        T* _ptr;                  // 指向资源的指针
        int* _refConut;           // 引用计数指针，记录有多少个 shared_ptr 管理同一个资源
        // 自定义删除器，可以删除任意类型的对象（默认使用 delete）
        std::function<void(T* ptr)> _del = [](T* ptr) { delete ptr; };

    public:
        shared_ptr(const T* ptr = nullptr)
            : _ptr(ptr), _refConut(new int(1))  // 初始化引用计数为 1，表示资源有一个管理者
        {
            std::cout << "shared_ptr构造: " << _ptr << " 数量: " << _refConut << std::endl;
        }

        // 构造函数：传入自定义删除器
        template <class D>
        shared_ptr(const T* ptr = nullptr, D del)
            : _ptr(ptr), _del(del), _refConut(new int(1))  // 自定义删除器
        {
            std::cout << "shared_ptr(const T* ptr = nullptr, D del)" << std::endl;
        }

        // 拷贝构造函数：增加引用计数
        shared_ptr(const shared_ptr<T>& other)
            : _ptr(other._ptr), _refConut(other._refConut)
        {
            ++(*_refConut);  // 引用计数加 1
        }

        // 释放资源：当引用计数减少为 0 时，释放资源
        void release() {
            if (--(*_refConut) == 0) {  
                _del(_ptr);  
                delete _refConut;  
                _ptr = nullptr;  
                _refConut = nullptr;  
            }
        }

        // 赋值运算符重载：释放旧资源，增加引用计数
        shared_ptr<T>& operator=(const shared_ptr<T>& other) {
            if (this != &other) {  // 防止自赋值
                release();  
                _ptr = other._ptr;  
                _refConut = other._refConut;  
                ++(*_refConut);  
            }
            return *this;
        }

        // 析构函数：调用 release 释放资源
        ~shared_ptr() { release(); }

        // 解引用运算符：返回指向的对象
        T* operator->() { return _ptr; }
        T& operator*() { return *_ptr; }

        // 获取原始指针
        T* get() { return _ptr; }

        // 获取当前引用计数
        int useCount() { return *_refConut; }
    };
}

 +----------------------+
 |   shared_ptr A       |                    +-----------------------+
 |----------------------|                    |  shared_ptr B         |
 | _ptr  -> [Resource]  |					 | _ptr  -> [Resource]   |
 | _refCount -> 2       |		  		     | _refCount -> 2        |
 +----------------------+                    +-----------------------+
        |                                            |
        v                                            v
    +---------+                                +---------+ 
    | Resource| 							   | Resource| 
    +---------+								/  +---------+
       |								  /
       v								/ 
    (delete called when refCount == 0)

template <class T>
struct ListNode {
    ListNode<T>* _prev = nullptr;
    ListNode<T>* _next = nullptr;

    ListNode() = default;
};

void test() {
    // 创建两个 ListNode<int> 节点，分别由 shared_ptr 管理
    shared_ptr<ListNode<int>> n1(new ListNode<int>);
    shared_ptr<ListNode<int>> n2(new ListNode<int>);

    // 形成双向链表关系
    //n1->_next = n2;   // n1 指向 n2
    //n2->_prev = n1;   // n2 指向 n1

    // 循环引用：n1 和 n2 互相持有对方的 shared_ptr
    // 当 test() 函数结束时，n1 和 n2 的引用计数永远不会为 0，资源不会被释放
}

 template <class T>
    class weak_ptr {
    private:
        T* _ptr = nullptr;
    public:
        weak_ptr() = default;
        weak_ptr(const shared_ptr<T>& sp)
            :_ptr(sp._ptr)  // 将 shared_ptr 的资源指针 _ptr 复制到 weak_ptr 的 _ptr 成员中
        {
            // 这里的构造函数将一个 shared_ptr 转换为 weak_ptr。
            // weak_ptr 不增加引用计数，它仅仅观察 shared_ptr 管理的资源。
            // 这样设计使得 weak_ptr 可以在不干扰资源生命周期的情况下，观察资源是否存在。
        }

        weak_ptr<T>& operator=(const shared_ptr<T>& other) {
            _ptr = other.get();  // 获取 shared_ptr 的资源指针并赋给 weak_ptr 的 _ptr 成员

            return *this;  // 返回当前的 weak_ptr 对象，以支持链式赋值操作
        }

        ~weak_ptr() {}
    };

template <class T>
struct ListNode {
    ListNode<T>* _prev = nullptr;
    ListNode<T>* _next = nullptr;

    ListNode() = default;
};

void test() {
    // 使用 weak_ptr 观察 n1 和 n2，而不增加引用计数
    weak_ptr<ListNode<int>> weak_n1(n1);  // weak_ptr 观察 n1
    weak_ptr<ListNode<int>> weak_n2(n2);  // weak_ptr 观察 n2

    // 现在，n1 和 n2 可以正确销毁，引用计数变为 0 时资源被释放
}