C++ 标准库中的异常 http://blog.youkuaiyun.com/hzhxxx/article/details/7616336

最新推荐文章于 2024-06-19 20:35:28 发布

转载最新推荐文章于 2024-06-19 20:35:28 发布 · 432 阅读

本文详细介绍了C++标准库中的异常处理机制，包括基类std::exception及其派生类std::logic_error和std::runtime_error的定义与使用。通过实例演示了如何自定义异常类并进行异常的抛出与捕获。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

http://blog.youkuaiyun.com/hzhxxx/article/details/7616336

C++ 标准库中的异常

1. 相关定义
标准库 c++ 异常类基类 std::exception 定义在文件 exception 中。
class exception
{
public:
    exception() throw() { }
    virtual ~exception() throw();
    /** Returns a C-style character string describing the general cause
    * of the current error. */
    virtual const char* what() const throw();
};

还有两个比较重要的子类是 std::logic_error,std::runtime_error,定义在文件 stdexcept中。
class logic_error : public exception
{
string _M_msg;

public:
/** Takes a character string describing the error. */
explicit logic_error(const string& __arg);

virtual ~logic_error() throw();

    /** Returns a C-style character string describing the general cause of
     * the current error (the same string passed to the ctor). */
    virtual const char* what() const throw();
};

定义后面都附带了 throw(),表示可以抛出任何异常。由定义可以看出，异常子类已经
采用std::string来作为异常内容输入了。

2. 应用举例

//主程序文件
#include <iostream>
#include <exception>
#include <stdexcept>
using namespace std;

class CMyEXception :public std::logic_error
{
private:
const std::string m_msg;

    const int m_errno;
public:
    explicit CMyEXception(const std::string &__arg,int ierrno = 0):logic_error(__arg),m_msg(__arg),m_errno(ierrno)
    {
        //
    }

    virtual ~CMyEXception() throw()
    {
        stdf::cout<<"~CMyEXception()"<<endl;
    }

    virtual const char* what() const throw()
    {
        //如有必要,覆盖基类的定义
         return m_msg.c_str();

}

    int geterrno()
    {
        return m_errno;
    }
};

int main()
{
        try
        {
             throw CMyEXception(std::string("dddd"),10);
             std::cout<<"after throw,not execute"<<endl;
        }
        catch(const CMyEXception &e)
        {
           std::cout<<"CMyEXception:"<<e.what()<<endl;
        }
        catch(const std::range_error &e)
        {
            std::cout<<"range_error:"<<e.what()<<endl;
        }
        catch(const std::runtime_error &e)
        {
            std::cout<<"runtime_error:"<<e.what()<<endl;
        }
        catch(const std::exception &e)
        {
            std::cout<<"exception:"<<e.what()<<endl;
        }
        catch(...)
        {
            std::cout<<"unexception ...:"<<endl;
        }
}

程序从main开始执行，构造异常类,抛出异常CMyEXception。
异常抛出后,异常后面的输出不会被执行。异常捕获的层次是先按
最匹配的开始,也就是异常类自身，随后是其直接父类，一直上溯
到最上层的父类,这里,首先被 CMyEXception 捕获,输出。
如果没有设置CMyEXception来捕获，那接着就应该是std::runtime_error,
最后是std::exception。程序最后要回到构造异常类的执行点，析构异常类。
如果捕获异常没有采用按应用调用，还要考虑通过子类构造一个父类的拷贝构造过程。
最后，异常调用栈退栈完成，调用才结束。