当前位置：首页 > news >正文

C++异常与智能指针

news 2025/10/15 13:05:10

异常

关于异常/错误的处理，C语言时期的方法是通过错误码的形式来处理错误。错误码类似于一个map，C语言内核会为每一个错误码附带一个错误信息，发生异常后便会给出错误码，接着我们需要拿着错误码去找错误信息，比较麻烦。在C++中异常处理机制得到了改善，使用的是异常的抛出与捕获方法。

当程序出现问题的时候，我们通过抛出(throw)一个对象来触发一个异常，接着由catch判断类型是否符合。每一个try都至少会匹配一个catch，否则就会报错。异常会优先找离自己最近的那个类型相同的catch，当发生了throw，程序就不会执行throw以后的程序，则是直接去找catch了，类似于return，只不过return是返回到栈的上一层，catch会先在本函数里面找catch，如果没找到符合的，会沿着调用链往上寻找，当他开始往上寻找，沿着调用链创建的对象都将被销毁。如果一直到main函数都没找到匹配的catch子句，程序会调用标准库的terminate函数。

#include <iostream>
using namespace std;
float Divide(int a, int b)
{try {if (b == 0){string s("除0了！！！！");throw s;}else{return (double)a / (double)b;}}catch (int id){cout << "id" << endl;}}void Func()
{int a, b;cin >> a >> b;try {cout << Divide(a, b) << endl;}catch (int errid){cout << errid<< endl;}
}int main()
{while (1){try{Func();}catch (string& error){cout << error << endl;}}return 0;
}

一般来说，抛出对象和catch类型是完全一致的，但是这个类型也允许一些例外，例如允许从非常量转为常量，数组转换为指向数组元素类型的指针，函数被转换为指向函数的函数指针，允许派生类向基类的转换，最后一点非常实用，在实际的工作流中都是用这个方法进行设计了。

class Exception
{public :Exception(const string& errmsg, int id): _errmsg(errmsg), _id(id){}virtual string what() const{return _errmsg;} int getid() const{return _id;}
protected:string _errmsg;int _id;
};
class SqlException : public Exception
{public :SqlException(const string& errmsg, int id, const string& sql): Exception(errmsg, id), _sql(sql){}virtual string what() const{string str = "SqlException:";str += _errmsg;str += "->";str += _sql;return str;}
private:const string _sql;
};
class CacheException : public Exception
{ 
public :
CacheException(const string & errmsg, int id)
: Exception(errmsg, id)
{
}
virtual string what() const
{
string str = "CacheException:";
str += _errmsg;
return str;
}
};
class HttpException : public Exception
{public :HttpException(const string& errmsg, int id, const string& type): Exception(errmsg, id), _type(type){}virtual string what() const{string str = "HttpException:";str += _type;str += ":";str += _errmsg;return str;}
private:const string _type;
};
void SQLMgr()
{if (rand() % 7 == 0){throw SqlException("权限不⾜", 100, "select * from name = '张三'");} else{cout << "SQLMgr 调⽤成功" << endl;}
}
void CacheMgr()
{if (rand() % 5 == 0){throw CacheException("权限不⾜", 100);} else if (rand() % 6 == 0){throw CacheException("数据不存在", 101);} else{cout << "CacheMgr 调⽤成功" << endl;} SQLMgr();
} 
void HttpServer()
{if (rand() % 3 == 0){throw HttpException("请求资源不存在", 100, "get");} else if (rand() % 4 == 0){throw HttpException("权限不⾜", 101, "post");} else{cout << "HttpServer调⽤成功" << endl;} CacheMgr();
} int main()
{srand(time(0));while (1){this_thread::sleep_for(chrono::seconds(1));try{HttpServer();} catch(const Exception & e) // 这⾥捕获基类，基类对象和派⽣类对象都可以被捕获{cout << e.what() << endl;} catch(...){cout << "Unkown Exception" << endl;}} return 0;
}

异常抛出后，后面的代码就不会执行了，会逐步的把在局部域内的对象给销毁，如果前面申请了资源，但是释放在throw后面，就会造成了内存泄漏的问题。如果要用逻辑程序来解决这个问题会很麻烦，因此就要用到我们下一章会提到的RAII方式。catch(...)表示的是啥都捕获。throw表示的是catch里面捕获到啥抛出啥，去寻找下一个符合类型的catch.

double Divide(int a, int b)
{// 当b == 0时抛出异常if (b == 0){throw "Division by zero condition!";} return(double)a / (double)b;
} 
void Func()
{// 这⾥可以看到如果发⽣除0错误抛出异常，另外下⾯的array没有得到释放。// 所以这⾥捕获异常后并不处理异常，异常还是交给外层处理，这⾥捕获了再// 重新抛出去。int* array = new int[10];try{int len, time;cin >> len >> time;cout << Divide(len, time) << endl;} catch(...){// 捕获异常释放内存cout << "delete []" << array << endl;delete[] array;throw; // 异常重新抛出，捕获到什么抛出什么} cout << "delete []" << array << endl;delete[] array;
} 
int main()
{try{Func();} catch(const char* errmsg){cout << errmsg << endl;} catch(const exception & e){cout << e.what() << endl;} catch(...){cout << "Unkown Exception" << endl;} return 0;
}

对于用户和编译器来说，如果能提前知道某个程序能不能抛出异常，我们就能对应的设计程序来简化代码，提高效率，在C++11中加入noexcept，函数参数列表后面加上noexcept表示不会抛出异常，啥都不加的话表示可能抛异常。一个函数如果用noexcept修饰了，但是里面还是有throw相关内容，编译还是会通过，但是如果这个函数触发了异常，程序会调用terminate终止程序,而非常见的catch捕捉机制。noexcept（expression）还可以用来检测一个表达式是否会抛异常，可能返回false（0），不会返回true（1）。noexcept不会检查内部的具体函数的

/ C++98
// 这⾥表⽰这个函数只会抛出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
size_type size() const noexcept;
iterator begin() noexcept;
const_iterator begin() const noexcept;
double Divide(int a, int b) noexcept
{
// 当b == 0时抛出异常
if (b == 0)
{
throw "Division by zero condition!";
} r
eturn (double)a / (double)b;
} i
nt main()
{
try
{
int len, time;
cin >> len >> time;
cout << Divide(len, time) << endl;
} c
atch (const char* errmsg)
{
cout << errmsg << endl;
} c
atch (...)
{
cout << "Unkown Exception" << endl;
} i
nt i = 0;
cout << noexcept(Divide(1,2)) << endl;
cout << noexcept(Divide(1,0)) << endl;
cout << noexcept(++i) << endl;
return 0;
}

智能指针

以前，当我们在new的时候，我们得匹配delete，new[]的时候，我们需要delete[]来进行匹配。但是此时如果抛异常了，或者提前return了，那么我们可能没有相应的可以释放内存的程序，就会导致内存泄漏。此时，我们使用智能指针，就能解决这个问题。

官方的智能指针包括auto_ptr,unique_ptr,shared_ptr,weak_ptr。其中auto_ptr完全不建议用，有指针悬空的问题。unique_ptr不允许拷贝，只允许移动。shared_ptr泛用性比较强，可以多个对象管理同一块空间。weak_ptr是为了解决shared_ptr可能的循环引用问题。

RAII与智能指针的设计思路

RAII是Resource Accqusition Initiallization的缩写，意为是资源获取初始化，本质上是将获取的动态资源利用对象生命周期来进行管理，这里的资源可以是内存，文件指针，网络连接等等，RAII获取资源后将其委托给一个对象，接着控制对资源的访问，资源在对象的声明周期时有效，对象析构的时候会释放资源，这样我们就能避免资源泄露。一般来说，智能指针还会重载 operator*/operator->/operator[] 等运算符。下面是关于shared_ptr的部分重新实现。

#include <functional>
namespace yu
{template <class T>class shared_ptr{public:shared_ptr(T* ptr): _ptr(ptr),_ptr_count(new int(1)){}template <class D>shared_ptr(T* ptr, D del): _ptr(ptr),_ptr_count(new int(1)),_del(del){}shared_ptr(const shared_ptr<T>& sp):_ptr(sp._ptr),_ptr_count(sp._ptr_count),_del(sp._del){(*_ptr_count)++;}void release(){if (--(*_ptr_count) == 0){delete _ptr;delete _ptr_count;}}~shared_ptr(){release();}shared_ptr& operator=(const shared_ptr& sp){if (_ptr != sp._ptr){release();_ptr == sp._ptr;_del = sp._del;_ptr_count = sp._ptr_count;(*_ptr_count)++;}return *this;}T& operator*(){return *_ptr;//返回解引用的内容}T* operator->(){return _ptr;//返回地址}int use_count() const{return *_ptr_count;}private:T* _ptr;int* _ptr_count;function<void(T*)> _del = [](T* ptr) {delete ptr;};//用包装器进行包装，void是返回类型，T*是参数};
}
int main()
{int* a = new(int);string* s = new(string);*a = 1;cout << *a << endl;yu::shared_ptr<int> sp1 = a;cout << *a << endl;//yu::shared_ptr<int> sp2 = a;报错！因为这样构造出来的对象未拥有同一个_ptr_count,虽然指向同一块空间，但是计数紊乱。后面析构的时候也会多次析构！智能通过sp1来构造yu::shared_ptr<int> sp2 = sp1;*sp2 = 4;cout << *sp2 << endl;return 0;
}

shared_ptr⼤多数情况下管理资源⾮常合适，⽀持RAII，也⽀持拷⻉。但是在循环引⽤的场景下会
导致资源没得到释放内存泄漏，所以我们要认识循环引⽤的场景和资源没释放的原因，并且学会使
⽤weak_ptr解决这种问题。
• 如下图所述场景，n1和n2析构后，管理两个节点的引⽤计数减到1
1. 右边的节点什么时候释放呢，左边节点中的_next管着呢，_next析构后，右边的节点就释放了。
2. _next什么时候析构呢，_next是左边节点的的成员，左边节点释放，_next就析构了。
比特就业课3. 左边节点什么时候释放呢，左边节点由右边节点中的_prev管着呢，_prev析构后，左边的节点就释
放了。
4. _prev什么时候析构呢，_prev是右边节点的成员，右边节点释放，_prev就析构了。
• ⾄此逻辑上成功形成回旋镖似的循环引⽤，谁都不会释放就形成了循环引⽤，导致内存泄漏
• 把ListNode结构体中的_next和_prev改成weak_ptr，weak_ptr绑定到shared_ptr时不会增加它的
引⽤计数，_next和_prev不参与资源释放管理逻辑，就成功打破了循环引⽤，解决了这⾥的问题

weak_ptr不支持RAII，weak_ptr也没有重载operator*和operator->等，因为他不参与资源管理，那么如果他绑定的shared_ptr已经释放了资源，那么他去访问资源就是很危险的。weak_ptr⽀持expired检查指向的资源是否过期，use_count也可获取shared_ptr的引⽤计数，weak_ptr想访问资源时，可以调⽤lock返回⼀个管理资源的shared_ptr，如果资源已经被释放，返回的shared_ptr是⼀个空对象，如果资源没有释放，则通过返回的shared_ptr访问资源是安全的。

查看全文

http://www.dtcms.com/a/483641.html