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

北京网聘信息技术有限公司上海seo关键词优化

wzjs 2025/8/13 4:51:42

北京网聘信息技术有限公司,上海seo关键词优化,科技有限公司可以做网站建设吗,门户网站建设情况简介文章目录异常的基本概念基本异常抛出与捕获多类型异常捕获异常重新抛出异常安全异常规范（noexcept）栈展开与析构标准库异常总结异常的基本概念异常是程序运行时发生的非预期事件（如除零、内存不足）。C通过try、catch和throw提…

文章目录

异常的基本概念
基本异常抛出与捕获
多类型异常捕获
异常重新抛出
异常安全
异常规范（noexcept）
栈展开与析构
标准库异常
总结

异常的基本概念

异常是程序运行时发生的非预期事件（如除零、内存不足）。C++通过try、catch和throw提供结构化处理机制，使程序能够优雅处理错误，而非直接崩溃。

核心思想：将错误处理与正常逻辑分离，提高代码可读性和健壮性。

基本异常抛出与捕获

场景：处理除零错误，抛出并捕获异常。

#include <iostream>
#include <stdexcept>  // 标准异常头文件double divide(double a, double b) 
{if (b == 0) {throw std::runtime_error("Error: Division by zero!");}return a / b;
}int main() 
{try {double result = divide(10, 0);std::cout << "Result: " << result << std::endl;} catch (const std::runtime_error& e) {std::cout << "Caught exception: " << e.what() << std::endl;}return 0;
}
输出：
Caught exception: Error: Division by zero!

说明：

throw 抛出一个 std::runtime_error 异常对象。
try 块内调用可能抛出异常的代码。
catch 捕获特定异常，e.what() 返回错误信息

多类型异常捕获

场景：根据错误类型抛出不同异常，并分别处理。

#include <iostream>
#include <stdexcept>void processInput(int value) 
{if (value < 0) {throw std::invalid_argument("Negative value not allowed!");} else if (value > 100) {throw std::out_of_range("Value exceeds limit!");}// 其他逻辑
}int main() 
{try {processInput(-5);  // 触发invalid_argument} catch (const std::invalid_argument& e) {std::cout << "Invalid Argument: " << e.what() << std::endl;} catch (const std::out_of_range& e) {std::cout << "Out of Range: " << e.what() << std::endl;} catch (...) {std::cout << "Unknown error!" << std::endl;}return 0;
}
输出：
Invalid Argument: Negative value not allowed!

说明：

多个 catch 块按顺序匹配异常类型。
catch (…) 捕获所有未被匹配的异常。

异常重新抛出

场景：中间层捕获异常后记录日志，重新抛出供上层处理。

#include <iostream>
#include <stdexcept>void lowLevel() 
{throw std::runtime_error("Low-level failure!");
}void highLevel() 
{try {lowLevel();} catch (const std::runtime_error& e) {std::cout << "Logged: " << e.what() << std::endl;throw;  // 重新抛出当前异常}
}int main() 
{try {highLevel();} catch (const std::runtime_error& e) {std::cout << "Main caught: " << e.what() << std::endl;}return 0;
}
输出：
Logged: Low-level failure!
Main caught: Low-level failure!

异常安全

核心原则

基本保证：异常发生后，程序处于有效状态（无资源泄漏）。
强保证：操作要么成功，要么状态回滚到操作前（类似事务）。
无抛出保证：操作绝不抛出异常（如swap）。

场景：使用智能指针确保资源在异常发生时自动释放。

#include <iostream>
#include <memory>
#include <stdexcept>class Resource 
{
public:Resource() { std::cout << "Resource acquired.\n"; }~Resource() { std::cout << "Resource released.\n"; }
};void riskyOperation() 
{auto res = std::make_unique<Resource>();  // RAII管理throw std::runtime_error("Oops, something broke!");// 即使抛出异常，res的析构函数也会被调用
}int main() 
{try {riskyOperation();} catch (const std::runtime_error& e) {std::cout << "Error: " << e.what() << std::endl;}return 0;
}
输出：
Resource acquired.
Resource released.
Error: Oops, something broke!

说明：

RAII（资源获取即初始化）通过对象生命周期管理资源。
智能指针（如 std::unique_ptr）确保内存自动释放。

异常规范（noexcept）

场景：标记不抛出异常的函数。

#include <iostream>
#include <stdexcept>void safeSwap(int& a, int& b) noexcept 
{  // 保证不抛出异常int temp = a;a = b;b = temp;
}int main() 
{int x = 10, y = 20;safeSwap(x, y);std::cout << "x=" << x << ", y=" << y << std::endl;return 0;
}
输出：
x=20, y=10

栈展开与析构

场景：异常抛出时，栈展开触发局部对象析构。

#include <iostream>
#include <stdexcept>class Logger 
{
public:Logger() { std::cout << "Logger created.\n"; }~Logger() { std::cout << "Logger destroyed.\n"; }
};void functionB() 
{Logger log;  // 局部对象throw std::runtime_error("Error in functionB");
}void functionA() 
{try {functionB();} catch (...) {std::cout << "Caught in functionA\n";throw;}
}int main() 
{try {functionA();} catch (...) {std::cout << "Caught in main\n";}return 0;
}
输出：
Logger created.
Logger destroyed.
Caught in functionA
Caught in main