zoukankan      html  css  js  c++  java
  • Summary of Exception

    0. Stack unwinding.When an exception is thrown and control passes from a try block to a handler, the C++ run time calls destructors for all automatic objects constructed since the beginning of the try block. This process is called stack unwinding.

    Two notes: 1) local objects will be destructed in reverse order; 2) if another exception thrown during stack unwinding in destructing an object, as no one can handle that exception, Terminate will be called to end the program. 

    View Code
    class BB
    {
    public:    
        BB() {  OutputDebugString(_T(
    "BB::BB()\n")); }
        
    virtual ~BB() {  OutputDebugString(_T("BB::~BB()\n")); throw 0; }
    };

    class DD : public BB
    {
    public:
        DD() {  OutputDebugString(_T(
    "DD::DD()\n")); }
        
    ~DD() {  OutputDebugString(_T("DD::~DD()\n")); }
    };

    class EE
    {
    public:
        EE() { OutputDebugString(_T(
    "EE::EE\n")); }
        
    ~EE() { OutputDebugString(_T("EE::~EE\n"));}
    };

    class FF
    {
    public:
        FF() { OutputDebugString(_T(
    "FF::FF\n")); }
        
    ~FF() { OutputDebugString(_T("FF::~FF\n")); /*throw 1;*/}
    };

    int _tmain(int argc, _TCHAR* argv[])
    {    
        
    try
        {
            FF ff;
            EE ee;
            BB
    * pBB = new DD();
            delete pBB;
        }    
        
    catch (...)
        {
            OutputDebugString(_T(
    "---get exception caught.\n"));
        }

        
    return 0;
    }

    Output:

    View Code
    FF::FF
    EE::EE
    BB::BB()
    DD::DD()
    DD::
    ~DD()
    BB::
    ~BB()
    First
    -chance exception at 0x76d8b727 (KernelBase.dll) in effPractice.exe: Microsoft C++ exception: int at memory location 0x0045f784..
    EE::
    ~EE
    FF::
    ~FF
    ---get exception caught.

    1. Exception Cost: When to throw and when not to
    To minimize your exception-related costs, compile without support for exceptions when that is feasible; limit your use of try blocks and exception specifications to those locations where you honestly need them; and throw exceptions only under conditions that are truly exceptional.
    1) level 1: compiling with exception support is the first factor to affect performance. If you compile your program without exception support, you can gain runtime performance improved. Here, exception support basically means: at runtime, there needs extra space/time to keep record of fully constructed objects so that when exception thrown, stack unwinding, objects can be destructed correctly.
    2) level 2: A second cost of exception-handling arises from try blocks, and you pay it whenever you use one, i.e., whenever you decide you want to be able to catch exceptions. Different compilers implement try blocks in different ways, so the cost varies from compiler to compiler. As a rough estimate, expect your overall code size to increase by 5-10% and your runtime to go up by a similar amount if you use try blocks. This assumes no exceptions are thrown; what we're discussing here is just the cost of having try blocks in your programs. To minimize this cost, you should avoid unnecessary try blocks.
    3) level 3: the cost of throwing an exception. Compared to a normal function return, returning from a function by throwing an exception may be as much as three orders of magnitude slower.

  • 相关阅读:
    python自学笔记
    mybatis审查要点
    session和cookie的简单理解
    linux命令
    [个人原创]关于java中对象排序的一些探讨(三)
    [技术翻译]Guava官方文档Ordering
    [个人原创]关于java中对象排序的一些探讨(二)
    [个人原创]关于java中对象排序的一些探讨(一)
    from 2666
    Euler Project question 34 in python way
  • 原文地址:https://www.cnblogs.com/taoxu0903/p/2119458.html
Copyright © 2011-2022 走看看