1
try{
2
    // 可能抛出异常的语句
3
}catch(exceptionType variable){
4
    // 处理异常的语句
5
}

1
//指针的切割
2
class Base{ };
3
class Derived: public Base{ };
4
int main(){
5
    try{
6
        Base* ptr = new Derived();
7
        throw ptr;
8
        cout<<"This statement will not be executed."<<endl;
9
    }
10
    catch(Derived*){
11
        cout<<"Exception type: Derived"<<endl;
12
    }
13
    catch(Base*){
14
        cout<<"Exception type: Base"<<endl;
15
    }
16
    return 0;
17
}
18
//这里抛base。因为ptr的静态类型是base
19

20
//引用的切割
21
class Base{ };
22
class Derived: public Base{ };
23
int main(){
24
    try{
25
        Derived d;
26
        Base& b = d;
27
        throw b;
28
        cout<<"This statement will not be executed."<<endl;
29
    }
30
    catch(Derived&){
31
        cout<<"Exception type: Derived"<<endl;
32
    }
33
    catch(Base&){
34
        cout<<"Exception type: Base"<<endl;
35
    }
36
    return 0;
37
}
38
//这里还是抛base。因为引用b的静态类型也是base
39

40
//正确匹配对象
41
class Base{ };
42
class Derived: public Base{ };
43
int main(){
44
    try{
45
        throw Derived();
46
        cout<<"This statement will not be executed."<<endl;
47
    }
48
    catch(Derived){
49
        cout<<"Exception type: Derived"<<endl;
50
    }
51
    catch(Base){
52
        cout<<"Exception type: Base"<<endl;
53
    }
54
    return 0;
55
}
56

57
//正确匹配指针
58
class Base{ };
59
class Derived: public Base{ };
60
int main(){
61
    try{
62
        throw new Derived();
63
        cout<<"This statement will not be executed."<<endl;
64
    }
65
    catch(Derived*){
66
        cout<<"Exception type: Derived"<<endl;
67
    }
68
    catch(Base*){
69
        cout<<"Exception type: Base"<<endl;
70
    }
71
    return 0;
72
}
73

74
//正确匹配引用
75
class Base{ };
76
class Derived: public Base{ };
77
int main(){
78
    try{
79
        throw Derived();
80
        cout<<"This statement will not be executed."<<endl;
81
    }
82
    catch(Derived&){
83
        cout<<"Exception type: Derived"<<endl;
84
    }
85
    catch(Base&){
86
        cout<<"Exception type: Base"<<endl;
87
    }
88
    return 0;
89
}

1
try{
2
    //可能抛出异常的语句
3
}catch (exception_type_1 e){
4
    //处理异常的语句
5
}catch (exception_type_2 e){
6
    //处理异常的语句
7
}
8
//其他的catch
9
catch (exception_type_n e){
10
    //处理异常的语句
11
}

1
class A
2
{
3
public:
4
    A() :a(0){ cout << "A默认构造函数" << endl; }
5
    A(const  A& rhs){ cout << "A拷贝构造函数" << endl; }
6
    ~A(){ cout << "A析构函数" << endl; }
7
private:
8
    int  a;
9
};
10
int main()
11
{
12
        try
13
        {
14
            A a ;
15
            throw a;
16
        }
17
        catch (A a) //注意这里
18
        {
19
            ;
20
        }
21
    return 0;
22
}
23
/*
24
A默认构造函数
25
A拷贝构造函数
26
A析构函数
27
A拷贝构造函数
28
A析构函数
29
A析构函数
30
*/

1
int main()
2
{
3
        try
4
        {
5
            A a ;
6
            throw a;
7
        }
8
        catch (A& a) //注意这里
9
        {
10
            ;
11
        }
12
    return 0;
13
}
14
/*
15
A默认构造函数
16
A拷贝构造函数
17
A析构函数
18
A析构函数
19
*/

1
class Base{
2
    public:
3
    virtual void print(){
4
        cout <<"base" << endl;
5
    }
6
};
7
class Derived: public Base{
8
    public:
9
    virtual void print(){
10
        cout <<"derived" << endl;
11
    }
12
 };
13

14

15
int main(){
16
    try{
17
        throw Derived();  //抛出自己的异常类型，实际上是创建一个Derived类型的匿名对象
18
        cout<<"This statement will not be executed."<<endl;
19
    }
20
    catch(Base e){ //值传递。无法多态。
21
        e.print(); //输出 base
22
    }
23

24
    return 0;
25
}

1
int main(){
2
    try{
3
        throw Derived();  //抛出自己的异常类型，实际上是创建一个Derived类型的匿名对象
4
        cout<<"This statement will not be executed."<<endl;
5
    }
6
    catch(Base& e){ //引用传递 虽然匹配无法多态，但是e本身可以多态。
7
        cout <<"catch base" << endl;
8
        e.print(); //输出derive
9
    }
10
    catch(Derived& e){
11
        cout <<"catch derived" << endl;
12
        e.print();
13
    }
14

15
    return 0;
16
}
17
/*
18
catch base //这里还是发生了提前匹配。
19
derived //对象本身可以多态。
20
*/

1
int main()
2
{
3
        try
4
        {
5
            A* a = new A;
6
            throw a;
7
        }
8
        catch (A* a)
9
        {
10
            delete a; //如果不delete则会内存泄漏
11
        }
12
    //或者放在这里也可以。
13
    return 0;
14
}

1
int main()
2
{
3
        try
4
        {
5
            A* a = new A;
6
            throw *a; //啥情况？？？
7
        }
8
        catch (A a)
9
        {
10
            ;
11
        }
12
    return 0;
13
}
14
/*
15
A默认构造函数
16
A拷贝构造函数
17
A拷贝构造函数
18
A析构函数
19
A析构函数
20
*/

1
class myexcept{
2
    public:
3

4
        string msg;
5
        myexcept(){
6
            cout <<"--const except--" << endl;
7
        }
8
        myexcept(const myexcept& obj){
9
            cout <<"--copy const except--" << endl;
10
        }
11
        myexcept(const string& s):msg(move(s)){
12
            cout <<"--const except--" << endl;
13
        };
14
        void what(){
15
            cout << msg << endl;
16
        }
17
        ~myexcept(){
18
            cout << "--desc except--" << endl;
19
        }
20
};
21

22
void func(){
23
    int errs = 0;
24
    for(int i = 0; i < 10; i++){
25
        try{
26
            cout << "try" << endl;
27
            throw myexcept("error occured");
28
        }
29
        catch (myexcept& e){
30
            cout <<"re-throw" << endl;
31
            e.msg = "too many err";
32
            throw;
33
        }
34
    }
35
}
36

37
int main(){
38
    try{
39
        func();
40
    }
41
    catch(myexcept& e){
42
        cout << "main" << endl;
43
        e.what();
44
    }
45

46
    return 0;
47
}
48
/*
49
try
50
--const except-- 构造异常对象
51
没有拷贝构造是因为编译器优化。
52
re-throw 进入catch准备rethrow
53
main 进入main
54
too many err 信息已被修改
55
--desc except-- 异常对象销毁。
56
*/

1
void func(){
2
    int errs = 0;
3
    for(int i = 0; i < 10; i++){
4
        try{
5
            cout <<"current is: " << i << endl;
6
            if(i%2 == 0){
7
                errs++;
8
                throw runtime_error("error occured");//注意这里
9
            }
10
        }
11
        catch (runtime_error& e){ //注意这里
12
            cout <<"error: " << e.what() << endl;
13
            if(errs >= 2){
14
                e = runtime_error("too many errors"); //注意这里发生了赋值
15
                throw e;
16
            }
17
        }
18
    }
19
}
20

21

22
int main(){
23
    try{
24
        func();
25
    }
26
    catch(runtime_error& e){ //注意这里
27
        cout << e.what() << endl;
28
    }
29

30
    return 0;
31
}

1
class A{
2
    public:
3
    A(){
4
        cout <<"A const" << endl;
5
    }
6
    ~A(){
7
        cout <<"A dest" << endl;
8
    }
9
};
10
class B{
11
    public:
12
    B(){
13
        cout <<"B const" << endl;
14
    }
15
    ~B(){
16
        cout <<"B dest" << endl;
17
    }
18
};
19
class myobj{
20
    public:
21
    A a;
22
    B b;
23
    myobj(){
24
        cout <<"myobj const" << endl;
25
        throw runtime_error("runtime error"); //构造函数中抛出异常。
26
    }
27
    ~myobj(){
28
        cout << "myobj dest" << endl;
29
    }
30
};
31

32
class myobj2 {
33
   public:
34
    A a;
35
    B b;
36
    myobj2() { cout << "myobj2 const" << endl; }
37
    myobj2(int x) : myobj2() {
38
        cout << "myobj2 int const" << endl;
39
        throw runtime_error("runtime error");  // 委托构造函数中抛出异常。
40
    }
41
    ~myobj2() { cout << "myobj2 dest" << endl; }
42
};
43

44
int main(){
45
    try{
46
        myobj a;
47
    }
48
    catch(exception& e){
49
        cout <<"error catched" << endl;
50
    }
51
    return 0;
52
}
53
/*
54
A const
55
B const
56
myobj const
57
B dest
58
A dest
59
error catched
60
注意！ 本类析构没有正确调用。
61
*/

1
class myExcept{ //异常对象
2
    public:
3
        enum m_errtype{NO_ERR, LENGTH_ERR, VALID_ERR, BOTH_ERR}; //枚举类，更加美观
4
        myExcept():m_ERRTYPE(NO_ERR){}; //默认构造函数，无异常
5
        myExcept(int x):m_ERRTYPE(LENGTH_ERR), length(x){}; //构造函数1：目的是实现第1种异常对象的构造
6
        myExcept(bool x):m_ERRTYPE(VALID_ERR), valid(x){}; //构造函数2：目的是实现第2种异常对象的构造
7
        myExcept(int x,bool y):m_ERRTYPE(BOTH_ERR), length(x), valid(y){}; //构造函数3：目的是实现第3种异常对象的构造
8
        void what() const{ //what函数模拟标准库exception类对象。这个函数会打印本类的具体错误。
9
            if(m_ERRTYPE == LENGTH_ERR){
10
                cout <<" EXCEPTION!! exceed length size: " << length << endl;
11
            }
12
            else if(m_ERRTYPE == VALID_ERR){
13
                cout <<" EXCEPTION!! not valid state: " << valid << endl;
14
            }
15
            else if(m_ERRTYPE == BOTH_ERR){
16
                cout <<" EXCEPTION!! exceed length: "<< length <<" and not valid state: " << valid << endl;
17
            }
18
        }
19
    private:
20
        m_errtype m_ERRTYPE; //错误类型
21
        int length; // 具体资源状态。用于显示具体错误。
22
        bool valid; // 具体资源状态。用于显示具体错误。
23
};
24

25
class myobj{
26
    public:
27
    int length;
28
    bool valid;
29
    myobj() = default;
30
    myobj(int x, bool y):length(x), valid(y){
31
        cout << "myobj constructed" << endl;
32
    }
33
    void test_func(int x, bool y){
34
        cout << "test func" << endl;
35
        if(x < 10 && y == false){
36
            throw myExcept(x,y);
37
        }
38
        else if(y == false){
39
            throw myExcept(y);
40
        }
41
        else if(x < 10){
42
            throw myExcept(x);
43
        }
44
    }
45
    ~myobj(){
46
        cout <<"myobj destructed" << endl;
47
    }
48
};
49

50
int main(){
51
    myobj obj(1,true);
52
    try{
53
        obj.test_func(0, true); //调用时刻。
54
    }
55
    catch(myExcept& e){
56
        e.what();
57
    }
58
    cout <<"main continued" << endl;
59
    return 0;
60
}
61
/*
62
第一种 obj.test_func(0, true);
63
myobj constructed
64
test func
65
 EXCEPTION!! exceed length size: 0
66
main continued
67
myobj destructed
68
剩下的不举例了。
69
*/

1
class A{
2
    public:
3
    int val;
4
    A(){
5
        cout <<"A const" << endl;
6
    }
7
    A(int x):val(x){
8
        cout <<"A const" << endl;
9
    }
10
    ~A(){
11
        cout <<"A dest" << endl;
12
    }
13
};
14
class B{
15
    public:
16
    int val;
17
    B(){
18
        cout <<"B const" << endl;
19
    }
20
    B(int x):val(x){
21
        cout <<"B const err" << endl;
22
        throw runtime_error("ERR"); //b的构造函数抛一个异常。
23
    }
24
    ~B(){
25
        cout <<"B dest" << endl;
26
    }
27
};
28
class myobj{
29
    public:
30
    A a;
31
    B b;
32
    myobj(int x, int y) try: a(x), b(y){ //try在这里。在初始化列表前。
33
        cout<<"myobj const" << endl;
34
    }
35
    catch(runtime_error& e){ //后面紧跟catch
36
        // cout << e.what() << endl;
37
        // throw;
38
        //这里就算不throw也会隐式安插throw
39
        //进入这个块之前，A会被析构。
40
    }
41
    ~myobj(){
42
        cout << "myobj dest" << endl;
43
    }
44
};
45

46
int main(){
47
    try{
48
        myobj a(1,2); //由于myobj构造函数一定会再次重抛异常到外面。所以这里必须再次用try catch接一下。
49
    }
50
    catch(runtime_error& e){
51
        cout << e.what() << endl;
52
    }
53
}

1
char a1[20];
2
char b1[300];
3
auto f = [a1](){}; //值捕获大小为20的数组
4
auto f1 = [&a1](){}; //引用捕获大小为20的数组
5
auto f2 = [b1](){}; //值捕获大小为300的数组
6
auto f3 = [&b1](){}; //引用捕获大小为300的数组
7
cout << sizeof(f) << endl; //20
8
cout << sizeof(f1) << endl; //8
9
cout << sizeof(f2) << endl;//300
10
cout << sizeof(f3) << endl;//8

1
std::function<int(int)> add_x(int x)
2
{
3
    return [&](int a) { return x + a; };
4
}

1
template <typename Func, typename... Args>
2
std::function<void()> addTask(Func &&f, Args&&... args){
3
    std::function<void()> func = [&](){ //注意这里是按照引用捕获了，有潜在bug
4
        f(std::forward<Args>(args)...);
5
    };
6
    return func;
7
}
8

9
void fuck1(int a){
10
    std::cout << a << std::endl;
11
}
12
void fuck2(int a, const std::string& b, double c){
13
    std::cout << a << b << c << std::endl;
14
}
15
int main(){
16
    std::vector<std::function<void()>> vecs;
17
    int input = 10;
18
    vecs.push_back(addTask(fuck1, 10)); //注意这里是右值。
19
    vecs.push_back(addTask(fuck2, 10, "abcde", 6.678));
20
    vecs[0]();
21
    vecs[1]();
22

23
}

1
int main(){
2
    int x = 100;
3
    auto cmp = [](const Person& a, const Person& b){return (a.id < b.id);
4
    };
5
    set<Person, decltype(cmp)> my_set(cmp); //set的自定义比较。利用decltype。必须传入构造函数。
6
    my_set.emplace(3,1);
7
    my_set.emplace(1,2);
8
    my_set.emplace(2,2);
9
    for(auto& i:my_set){
10
        cout << i.id << " " << i.day << endl;
11
    }
12

13

14

15
    vector<Person> my_vec;
16
    my_vec.emplace_back(3,1);
17
    my_vec.emplace_back(1,2);
18
    my_vec.emplace_back(2,2);
19
    sort(my_vec.begin(), my_vec.end(), [](const Person& a, const Person& b){return a.id < b.id;}); //sort的自定义排序
20
    for(auto& i:my_vec){
21
        cout << i.id << " " << i.day << endl;
22
    }
23
    return 0;
24

25
}

1
bool less_certain(int val, int elem){
2
    return elem < val;
3
}
4
int main(){
5
    vector<int>a{1,2,3,4,5,6,7};
6
    int val = 7;
7
    int num = count_if(a.begin(), a.end(), bind(less_certain, val, std::placeholders::_1));
8
    cout << num << endl;
9
}

1
int main(){
2
    vector<int>a{1,2,3,4,5,6,7};
3
    int val = 7;
4
    int num = count_if(a.begin(), a.end(), [val](int elem){
5
        return elem < val;
6
    });
7
    cout << num << endl;
8
}