目录
引言
在当今的软件开发领域，程序的健壮性和稳定性一直是开发者追求的核心目标。C++作为一门强大的编程语言，其异常处理机制为开发者提供了一种有效的手段来应对程序运行过程中可能出现的意外情况。通过合理地运用异常处理，我们能够确保程序在面对错误时能够优雅地处理，从而保障系统的稳定运行。接下来，本文将介绍C++的异常处理机制，以及如何在实践中发挥其巨大作用。
1.C语言传统的处理错误的方式
2. C++异常概念
try
{
// 保护的标识代码
}catch( ExceptionName e1 )
{
// catch 块
}catch( ExceptionName e2 )
{
// catch 块
}catch( ExceptionName eN )
{
// catch 块
}3. 异常的使用
double Division(int a, int b)
{
// 当b == 0时抛出异常
if (b == 0)
throw "Division by zero condition!";
else
return ((double)a / (double)b);
}
void Func()
{
int len, time;
cin >> len >> time;
cout << Division(len, time) << endl;
}
int main()
{
try {
Func();
}
catch (const char* errmsg） {
cout << errmsg << endl;
}
catch(...){
cout<<"unkown exception"<<endl;
}
return 0;
}这里的catch（...）可以捕获任意类型的异常。
例2：
抛出的对象传给str 。出现错误之后，会从出现异常的位置直接跳跃到catch语句处
中间的栈帧任意一层都可以捕获异常。
抛完异常之后，并不会执行A这条语句。而是直接跳跃到捕获异常处。
但是如果A这条语句在函数调用之前，那么异常发生还是会正确调用A的析构，即栈帧会正确的销毁
这个栈帧示意图可以理解为一个调用链，在调用链的任意位置捕获都可以
如果有多个try-catch，会走最近的tay-catch语句。
捕获时类型匹配不上，直接终止程序。但是如果多个捕获只有一个类型可以匹配，那么将只匹配对应的类型
在函数调用链中异常栈展开匹配原则
1. 首先检查throw本身是否在try块内部，如果是再查找匹配的catch语句。如果有匹配的，则
调到catch的地方进行处理。
2. 没有匹配的catch则退出当前函数栈，继续在调用函数的栈中进行查找匹配的catch。
3. 如果到达main函数的栈，依旧没有匹配的，则终止程序。上述这个沿着调用链查找匹配的
catch子句的过程称为栈展开。所以实际中我们最后都要加一个catch(...)捕获任意类型的异
常，否则当有异常没捕获，程序就会直接终止。
4. 找到匹配的catch子句并处理以后，会继续沿着catch子句后面继续执行。
问题：抛出的异常是 S吗？
抛出的是s吗？当然不是S的生命周期只在当前作用域。返回的是一个临时对象（右值）。类似传值返回，代价很大。
但是移动拷贝的存在使得代价很低下。
Std库里的异常处理，只管用exception捕获就可以（箭头指向基类）
我们可以直接catch（exception& e)去接收异常信息
std库所有的异常都是自己抛出的吗？
在C++标准库中，异常通常是在发生错误时由库函数自动抛出的，但是也有一些情况下需要程序员显式地抛出异常。以下是一些常见的异常抛出情况：
自动抛出：标准库函数在检测到错误时会自动抛出异常。例如：
分配内存失败时，new操作符会抛出std::bad_alloc异常。
容器操作（如std::vector的push_back或insert）在内存不足时可能会抛出std::bad_alloc。
输入输出流操作（如std::ios_base::failure）在遇到错误时会抛出异常。
算法中的错误检查，如std::sort在比较函数违反了严格弱序时可能会抛出std::logic_error或其派生类。
显式抛出：程序员可以显式地使用throw关键字抛出标准库中的异常类。例如，当检测到程序中的逻辑错误时，程序员可能会抛出std::logic_error或其派生类（如std::domain_error、std::invalid_argument等）。
以下是一些显式抛出异常的例子：
#include <stdexcept>
void do_something(int value) {
if (value < 0) {
throw std::invalid_argument("value must be non-negative");
}
// ... do something with value ...
}
void some_function() {
try {
do_something(-1); // 显式抛出异常
} catch (const std::invalid_argument& e) {
std::cerr << "Caught exception: " << e.what() << '\n';
}
}what()是std::exception类的一个公共成员函数，它提供了一个异常接口，用于返回与异常相关的字符串信息。这个函数返回一个指向常量字符数组的指针，该数组包含了异常的描述信息。
当你捕获到一个std::exception或其派生类的对象时，你可以调用what()方法来获取这个描述信息，通常用于错误报告或日志记录。
下面是std::exception类中what()函数的原型：
const char* what() const noexcept;
自动抛异常的例子
在C++中，标准库中的某些函数和对象会在特定条件下自动抛出异常。例如，std::vector的at成员函数会在索引越界时抛出std::out_of_range异常。以下是一个例子，演示了如何手动接收由标准库自动抛出的异常：
#include <iostream>
#include <vector>
#include <stdexcept> // 包含标准异常库
int main() {
std::vector<int> vec = {1, 2, 3, 4, 5}; // 创建一个包含5个元素的vector
try {
// 尝试访问越界的元素，这将自动抛出std::out_of_range异常
std::cout << "Element at index 10: " << vec.at(10) << std::endl;
}
catch (const std::out_of_range& e) {
// 捕获并处理std::out_of_range异常
std::cerr << "Caught an exception: " << e.what() << std::endl;
}
catch (...) {
// 捕获所有其他类型的异常
std::cerr << "Caught an unexpected exception." << std::endl;
}
return 0;
}
在这个例子中，我们创建了一个std::vector对象vec，并尝试使用at成员函数访问索引为10的元素。由于vec只包含5个元素，索引10超出了范围，因此at函数会自动抛出std::out_of_range异常。
在try块中，我们放置了可能抛出异常的代码。在随后的catch块中，我们捕获并处理了这个特定的异常类型std::out_of_range。如果捕获到这个异常，程序将打印出异常的描述信息。
请注意，C++标准库中有很多操作可以自动抛出异常，例如使用std::string的at函数，或者在std::vector中进行越界访问等。这个例子仅展示了其中一种情况。
上述代码会打印以下内容：
Caught an exception: vector::_M_range_check: __n (which is 10) >= this->size() (which is 5)
CPP的new出现异常是自动抛异常吗？
在C++中，当使用new操作符进行动态内存分配失败时，默认的行为是抛出一个类型为std::bad_alloc的异常。如果new操作符无法分配所需的内存，它将自动抛出这个异常，开发者可以选择捕获并处理这个异常。
例如：
try {
int* p = new int[1000000000]; // 尝试分配一个非常大的内存块
} catch (const std::bad_alloc& e) {
std::cerr << "内存分配失败: " << e.what() << '\n';
}在这个例子中，如果内存分配失败，new操作符将抛出std::bad_alloc异常，然后在catch块中被捕获和处理。如果不捕获这个异常，程序通常会异常终止。需要注意的是，开发者也可以通过new(std::nothrow)来请求new在分配失败时不抛出异常，而是返回一个空指针。
异常的重新抛出
double Division(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 << Division(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;
}
return 0;
}int* array = new int[10];
try {
int len, time;
cin >> len >> time;
cout << Division(len, time) << endl;
}
catch (...)
{
cout << "delete []" << array << endl;
delete[] array;
throw;
}
// ...
cout << "delete []" << array << endl;
delete[] array;
}上面就是一场重新抛出的核心逻辑。其中直接throw就表示捕捉到了什么异常，就会抛出什么异常。
异常安全
异常抛出，会跳跃到catch语句处，也就意味着，如果此时异常语句下面存在delete语句，那么将会存在内存泄露问题吗？（CPP）
在C++中，异常的抛出会导致程序的控制流跳转到最近的匹配的catch块。如果在异常抛出之前调用了new操作符分配了内存，并且在异常抛出之后没有相应的delete调用释放内存，那么确实可能发生内存泄露。
考虑以下代码示例：
void someFunction() {
MyObject* pObj = new MyObject();
// 假设这里发生了异常，并且没有被处理
throw std::exception(); // pObj没有被释放
// 如果没有异常，正常执行下面的代码
delete pObj; // pObj在这里被释放
}
int main() {
try {
someFunction();
}
catch (...) {
// 处理异常
}
return 0;
}在上面的代码中，如果在new MyObject()之后和delete pObj;之前发生了异常，那么pObj指向的内存不会被释放，导致内存泄露。
异常规范
// 这里表示这个函数会抛出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;当然，这不是绝对的，这只是一种规范，并不是规矩。
只不过noexcept关键字之后，如果抛出了异常，也不允许catch！
自定义异常体系
// 服务器开发中通常使用的异常继承体系
class Exception
{
public:
Exception(const string& errmsg, int id)
:_errmsg(errmsg)
,_id(id)
{}
virtual string what() const
{
return _errmsg
}
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 HttpServerException : public Exception
{
public:
HttpServerException(const string& errmsg, int id, const string& type)
:Exception(errmsg, id)
, _type(type)
{}
virtual string what() const
{
string str = "HttpServerException:";
str += _type;
str += ":";
str += _errmsg;
return str;
}
private:
const string _type;
};
void SQLMgr()
{
srand(time(0));
if (rand() % 7 == 0)
{
throw SqlException("权限不足", 100, "select * from name = '张三'");
}
//throw "xxxxxx";
}
void CacheMgr()
{
srand(time(0));
if (rand() % 5 == 0)
{
throw CacheException("权限不足", 100);
}
else if (rand() % 6 == 0)
{
throw CacheException("数据不存在", 101);
}
SQLMgr();
}
void HttpServer()
{
// ...
srand(time(0));
if (rand() % 3 == 0)
{
throw HttpServerException("请求资源不存在", 100, "get");
}
else if (rand() % 4 == 0)
{
throw HttpServerException("权限不足", 101, "post");
}
CacheMgr();
}
int main()
{
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;
}
// 1.下面这段伪代码我们可以看到ConnnectSql中出错了，先返回给ServerStart，
ServerStart再返回给main函数，main函数再针对问题处理具体的错误。
// 2.如果是异常体系，不管是ConnnectSql还是ServerStart及调用函数出错，都不用检查，因
为抛出的异常异常会直接跳到main函数中catch捕获的地方，main函数直接处理错误。
int ConnnectSql()
{
// 用户名密码错误
if (...)
return 1;
// 权限不足
if (...)
return 2;
}
int ServerStart() {
if (int ret = ConnnectSql() < 0)
return ret;
int fd = socket()
if（fd < 0）
return errno;
}
int main()
{
if(ServerStart()<0)
...
return 0;
}throw()列表（也称为异常规范）来指定函数可以抛出的异常类型，但
这在C++11中已经被弃用，并在C++17中完全移除。异常规范的使用如下：
noexcept说明符： C++11引入了noexcept关键字，用于指定函数不会抛出异常。如果函数声明为noexcept，那么如果它抛出了异常，程序会直接调用std::terminate来终止。
void myFunction() noexcept; // 指定函数不会抛出异常
扫一扫
573
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
