c++异常处理（c++11版）与智能指针 SmartPtr 的应用（主讲shared

引子：找C语言的异常时，你是否会被奇怪的错误码或程序终止报错而感到无奈，对找不到错误在哪的心烦？在害怕内存泄漏时，你是否每一步，每一句代码都要仔细分析，在用完之后进行资源空间的释放？你是否......,今天我们讲的c++异常处理（c++11版）与智能指针的应用（主讲shared_ptr浅实现），希望可以帮助你

C++11的异常概念与异常处理关键字：try,throw，catch

C++11的异常处理简称抛异常，异常是一种处理错误的方式，当一个函数发现自己无法处理的错误时就可以抛出异常，让函数的直接或间接的调用者处理这个错误。

try: 用于指定一个代码块，在该代码块中可能会抛出异常。

throw: 用于抛出一个异常。

catch: 用于捕获并处理异常。

异常处理的基本语法

try {
    // 尝试执行的代码
    if (some_condition) {
        throw some_error; // 抛出异常
    }
} catch (SomeExceptionType e) { // 捕获特定类型的异常
    // 处理异常
} catch (...) { // 捕获所有类型的异常
    // 通用异常处理
}

c++11异常的抛出和匹配原则

1，异常是通过抛出对象而引发的，该对象的类型决定了应该激活哪个catch的处理代码。

2. 被选中的处理代码是调用链中与该对象类型匹配且离抛出异常位置最近的那一个。

3. 抛出异常对象后，会生成一个异常对象的拷贝，因为抛出的异常对象可能是一个临时对象，所以会生成一个拷贝对象，这个拷贝的临时对象会在被catch以后销毁。（这里的处理类似于函数的传值返回）

4. catch(...)可以捕获任意类型的异常，问题是不知道异常错误是什么。

5. （重中之中）实际中抛出和捕获的匹配原则有个例外，并不都是类型完全匹配，可以抛出的派生类对象，使用基类捕获，这个在实际中非常实用

在函数调用链中异常栈展开匹配原则

1,首先检查throw本身是否在try块内部，如果是再查找匹配的catch语句。如果有匹配的，则调到catch的地方进行处理。

2. 没有匹配的catch则退出当前函数栈，继续在调用函数的栈中进行查找匹配的catch。

3. 如果到达main函数的栈，依旧没有匹配的，则终止程序。上述这个沿着调用链查找匹配的 catch子句的过程称为栈展开。所以实际中我们最后都要加一个catch(...)捕获任意类型的异常，否则当有异常没捕获，程序就会直接终止。

4. 找到匹配的catch子句并处理以后，会继续沿着catch子句后面继续执行。

对于异常的二种常用的手段：

一，多尝试几次，可能是网络不稳定或其他原因导致偶然性，故可以多试几次。

二，使用重新抛出，进一步来收缩错误范围

c++异常安全

1，构造函数完成对象的构造和初始化，最好不要在构造函数中抛出异常，否则可能导致对象不完整或没有完全初始化

2，析构函数主要完成资源的清理，最好不要在析构函数内抛出异常，否则可能导致资源泄漏(内存泄漏、句柄未关闭等)

3，C++中异常经常会导致资源泄漏的问题，比如在new和delete中抛出了异常，导致内存泄漏，在lock和unlock之间抛出了异常导致死锁，C++经常使用RAII来解决以上问题

异常规范：

1. 异常规格说明的目的是为了让函数使用者知道该函数可能抛出的异常有哪些。可以在函数的后面接throw(类型)，列出这个函数可能抛掷的所有异常类型。

2. 函数的后面接throw()，表示函数不抛异常。

3. 若无异常接口声明，则此函数可以抛掷任何类型的异常

4,C++11 中新增的noexcept，表示不会抛异常

自定义异常体系（一般公司都有用）

举例as：

// 自定义异常类
class MyException{
private:
    std::string message; // 存储错误信息

public:
    // 构造函数
    MyException(const std::string& msg) : message(msg) {}

    // what()函数，可以有多态行为
    virtual const char* what() const throw() 
    {
        return message.c_str();
    }
};


class BaseException : public MyException {
    // ...
};

class NetworkException :  public MyException {
    // 网络相关的异常
    // ...
};

class DatabaseException : public MyException {
    // 数据库相关的异常
    // ...
};


使用：
try {
    // 可能抛出多种异常的代码
} catch (const MyException& e) {
    // 处理自定义异常
}catch (...) {
    // 处理其他异常
}

异常的优缺点：

c++异常的优点：

1.异常对象定义好了，相比错误码的方式可以清晰准确的展示出错误的各种信息，甚至可以包含堆栈调用的信息，这样可以帮助更好的定位程序的bug。

2.返回错误码的传统方式有个很大的问题就是，在函数调用链中，深层的函数返回了错误，那么我们得层层返回错误，最外层才能拿到错误，

3.很多的第三方库都包含异常，比如boost、gtest、gmock等等常用的库，那么我们使用它们也需要使用异常。

4. 部分函数使用异常更好处理，比如构造函数没有返回值，不方便使用错误码方式处理。比如 T& operator这样的函数，如果pos越界了只能使用异常或者终止程序处理，没办法通过返回值表示错误。

C++异常的缺点：

1. 异常会导致程序的执行流乱跳，并且非常的混乱，并且是运行时出错抛异常就会乱跳。这会导致我们跟踪调试时以及分析程序时，比较困难。

2. 异常会有一些性能的开销。当然在现代硬件速度很快的情况下，这个影响基本忽略不计。

3. C++没有垃圾回收机制，资源需要自己管理。有了异常非常容易导致内存泄漏、死锁等异常安全问题。这个需要使用RAII来处理资源的管理问题。学习成本较高。

4. C++标准库的异常体系定义得不好，导致大家各自定义各自的异常体系，非常的混乱。

5. 异常尽量规范使用，否则后果不堪设想，随意抛异常，外层捕获的用户苦不堪言。所以异常规范有两点：一、抛出异常类型都继承自一个基类。二、函数是否抛异常、抛什么异常，都使用 func（） throw();的方式规范化。

、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、

智能指针（SmartPtr ）的应用（主讲shared_ptr浅实现）

首要说明：c++的智能指针用来解决内存泄漏的问题！

原理：Rall:一种利用对象生命周期来控制程序资源（如内存、文件句柄、网络连接、互斥量等等）的简单技术.

一般有以下几种：

auto_ptr的实现原理：管理权转移的思想，下面简化模拟实现了一份bit::auto_ptr来了解它的原理

unique_ptr的实现原理：简单粗暴的防拷贝，下面简化模拟实现了一份UniquePtr来了解它的原理

shared_ptr的原理：是通过引用计数的方式来实现多个shared_ptr对象之间共享资源。

share_ptr实现代码：包括测试代码：

template <typename T>
class Shared_Ptr {
private:
    T* _ptr; // 指向管理对象的指针
    int* _count; // 引用计数
    function<void(T* ptr)> _del = [](T* ptr) {delete ptr; };//自定义删除
public:
    // 构造函数
   Shared_Ptr(T* ptr = nullptr) 
       : _ptr(ptr)
       ,_count(new int(1))
   {}

   template<class D>
   Shared_Ptr(T* ptr, D del)
       : _ptr(ptr)
       , _count(new int(1))
       , _del(del)
   {}

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

    void release()
    {
        if (--(*_count) == 0)
        {
            //delete _ptr;
            _del(_ptr);

            delete _count;
            _ptr = nullptr;
            _count = nullptr;
        }
    }
 
    // 赋值操作符
    Shared_Ptr& operator=(const Shared_Ptr<T>& other) {
        if (this != &other) {
            // 减少当前对象的引用计数，如果计数为0，则释放资源
            if (--(*_count) == 0) {
                release();
            }
            // 复制新的指针和计数
            _ptr = other._ptr;
            _count = other._count;
            ++(*_count);
        }
        return *this;
    }


    // 析构函数
    ~Shared_Ptr() {
        release();
        cout << "delete" << endl;
    }

    // 解引用操作符
    T& operator*() const {
        return *_ptr;
    }

    // 成员访问操作符
    T* operator->() const {
        return _ptr;
    }

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

    // 检查是否为空
    bool empty() const {
        return _ptr == nullptr;
    }

    // 重置智能指针
    void reset(T* p = nullptr) {
        if (p != _ptr) {
            release();
            _ptr = p;
            _count = new int(1);
        }
    }

    // 引用计数的当前值
    unsigned use_count() const {
        return *_count;
    }
};

int main()
{
    Shared_Ptr<int> h1(new int[10]);
    Shared_Ptr<int> h2(h1);
    Shared_Ptr<int> h3(h2);

    cout << h1.use_count() << endl;
    cout << h2.use_count() << endl;
    cout << h3.use_count() << endl;

    Shared_Ptr<int> sp6((int*)malloc(40), [](int* ptr)
    {
          cout << "free:" << ptr << endl;
    	  free(ptr);
    });

    return 0;
}