1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
#include <iostream>                                                             
 
class A{
    public:
        A(void){
            std::cout << "A::A()" << std::endl;
        }
        ~A(void){
            std::cout << "A::~A()" <<std::endl;
        }
};
 
class B:public A{
    public:
        B(void){
            std::cout << "B::B(void)"<<std::endl;
        }
        ~B(void){
            std::cout << "B::~B(void)" << std::endl;
        }
};
void func(void){
   throw A(); //这里抛出一个匿名A类对象.
    //这里调用A的构造函数,直接跳转到},跳转到"}",但是不执行匿名的析构函数
    std::cout << "func()" << std::endl; //这里不执行
}
int main(void){
    try { //这里try 和catch都是一个局部作用域,和函数一样
        func();//直接跳转到'}',但是从func函数里,抛出的异常对象的析构函数
               //还是不调用 
        std::cout << "try" << std::endl; //不执行
    }
    catch(A& ex){ //这里对异常抛出的异常对象进行捕捉,如果捕捉不到,则    
                    //直接跳转到下一个catch语句...,
        std::cout << "catch A"<<std::endl;
        return -1;
    }//这里执行匿名对象的析构函数
    std::cout << "main endl..." <<std::endl;
    return 0;
}


catch子句会根据异常的类型自上而下顺序匹配,而不是最优匹配

catch子句中使用引用接受异常对象,避免拷贝构造的性能开销,同时可以减少浅拷贝的风险



1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
#include <iostream>
class A{                                                                        
    public:
        A(){
            std::cout << "A::A()" << std::endl;
        }
        ~A(){
            std::cout << "A::~A()" << std::endl;
        }
};
 
class B{
    public:
        B(){
            std::cout << "B::B()" << std::endl;
        }
        ~B(){
            std::cout << "B::~B()" << std::endl;
        }
};
 
class C{
    public:
        C(){
            std::cout << "C::C()" << std::endl;
        }
        ~C(){
            std::cout << "C::~C()" << std::endl;
        }
};
 
void func(void){
    throw C();//调用C的构造函数,直接跳转到'}'
}
int main(void){
 
    try{
        func();//直接跳转到'}'
    }
    catch(int& ex){//这里发现int& ex = 匿名对象,不成立,则直接倒转到转到'}'
        std::cout << "catch:int" << std::endl;//不执行
    }
    catch(B& ex){//B& ex =匿名对象,不成立,直接跳转到'}'
        std::cout << "catch:B" << std::endl;//不执行   
           }
    catch(C& ex){//C& ex = 匿名对象,成立,则执行catch体内的语句
        std::cout << "catch:C" << std::endl;//执行
    }//这里调用匿名对象的析构函数
    return 0;
}