C++（八）——异常处理和转换函数

异常

异常是程序在执行期间产生的问题。其中涉及三个关键字：try、catch、throw。
设计者知道程序什么时候会出错  抛出异常，作为使用者应该做的是去监听异常，并且处理异常。

throw：当问题出现时，程序会抛出一个异常。这是通过使用 throw 关键字来完成的。
catch：在想要处理问题的地方，通过异常处理程序捕获异常。catch 关键字用于捕获异常。
try： try 块中的代码标识将被激活的特定异常。它后面通常跟着一个或多个 catch 块。


可以继承标准异常类 exception
1
2
3
4
5
6
7
8
9

异常处理示例

#include 
#include 
#include 

using namespace std;

class MyException:public exception
{
    public:
        MyException(const string &err):errmsg(err.data()){}

        MyException(const char * err ):errmsg(err){}

        const char * what() const noexcept
        {
            return errmsg;
        }

    private:
        const char * errmsg;
};

void func(int x)
{
    if( x == 0 )
    {
        throw MyException("x == 0");
    }
    if( x < 0 )
    {
        throw MyException("x < 0");
    }
}
int main()
{

    int x;
    cin>>x;

    try
    {
        func(x);
    }
    catch(MyException & err)
    {
        cout<<err.what()<<endl;
    }

    return 0;
}
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

转换函数

作用：类型转换

和强转的区别：让阅读者更容易阅读代码
explicit：防止隐式类型转换  

1
2
3
4
5

reinterpret_cast

#include 

using namespace std;

class A
{
};

class B
{
};

int main()
{
    char *p = nullptr;
    int *q = nullptr;

    p = (char*)q;//int* 强转为char*
    p = reinterpret_cast<char *>(q);

    //char * 转为 unsigned long
    unsigned long j = (unsigned long)p; 
    unsigned long i = reinterpret_cast<unsigned long >(q); //int * 转为 unsigned long

    //不同类的对象指针转化
    A *a = new A;
    B *b = new B;

    a = (A*)b;
    a = reinterpret_cast<A*>(b);


}
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

指针类型的转换

const_cast

const 和非const转换
1

#include 

using namespace std;

class A 
{
};

class B 
{
};

int main()
{
    char buf[] = "hello";

    const  char *p = buf;

    //const char * 强转为char *
    char *q = (char *) p;
    *q = 'A';

    char *o = const_cast<char *>(p);
    *o = 'o';

    //char * 转为const char*
    const char * o1 = const_cast<const char * >(o);

    //
    A* a = new A;
    const A* b = (const A*)a;
    const A* bq= const_cast<const A*>(a);


    B* c = new B ;
    b = (const A*)c;

    cout<<q<<endl;

    return 0;
}
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

static_cast

普通类型， 继承关系
1

#include 

using namespace std;

class Base
{
    public:
        explicit Base(){}

        virtual ~Base(){}

        void func()
        {
            cout<<"hello 🐼"<<endl;
        }
};

class Inhrit:public Base
{
    public:
        explicit Inhrit(){}

        ~Inhrit(){}

        void func()
        {
            cout<<"world 🐼"<<endl;
        }
};


int main()
{

    int a = 1;

    //int => char
    char c = static_cast<char>(a);

    Base *base = new Base ;
    Inhrit * in = static_cast<Inhrit*>(base);
    in->func();

    Inhrit *in1 = new Inhrit;
    Base *base1 = static_cast<Base*>(in1);
    in1->func();



    return 0;
}
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
51

dynamic_cast

继承关系，安全，虚函数
1

#include 

using namespace std;

class Base 
{
    public:
        explicit Base(){}

        virtual ~Base(){}

        virtual void func()
        {
            cout<<"hello diaomaozai 🐼"<<endl;
        }
};

class Inhrit:public Base
{
    public:
        explicit Inhrit(){}

        ~Inhrit(){}

        void func()
        {
            cout<<"world 🐼🐼"<<endl;
        }
};

int main()
{

        Inhrit *in = new Inhrit ;
        
        Base * base = dynamic_cast<Base*>(in);
        Base * base1 = static_cast<Base*>(in);

        base->func();
        base1->func();
    return 0;
}
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

用户自定义转换函数

 operator int()const

 {

 ​	return x;

 }

成员函数

 没有返回值

一般是const
注意和运算符重载造成歧义（慎用）
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

#include 

using namespace std;

class B
{
    int i;
};

class A
{
        int i ;
        B j ;
    public:
        A(int i = 1):i(i){}

        operator int ()const
        {
            cout<<"hello 🐼"<<endl;
            return i;
        }

        operator B () const
        {
            cout<<"hello B"<<endl;
            return j;
        }
};
int main()
{

    A a;
    int i ;

    i = a;
    B b = a;
    return 0;

}
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