自学 C++ day15 异常&类型装换

// 异常：
// 异常的使用：
// 1. 异常是通过抛出对象而引发的，该对象的类型决定了应该激活那个catch的处理代码。
// 2. 被选中的处理代码是调用链中与该对象类型匹配且距离异常抛出位置最近的哪一个！
// 3. 抛出一个一场对象后，会生成一个异常对象的拷贝，因为抛出的异常对象可能是一个临时对象，所以会产生一个拷贝对象
// 这个拷贝的临时对象会在被catch后销毁。
// 4. catch(...) 可以捕捉任意类型的异常，问题是不知道异常错误是什么.
// 5. 实际中抛出和补货的匹配原则有个例外，并不都是完全匹配，使用基类捕获也可以。
#include <iostream> 
using namespace std;
#if 0
double divide(int a, int b) {
	if (b == 0) {
		throw "Division by zeor condition";
	}
	else {
		return ((double)a / (double)b);
	}
}

void Func() {
	int len, time;
	cin >> len >> time;
	cout << divide(len, time) << endl;
}

int main() {
	try {
		Func();
	}
	catch (const char* errmsg) {
		cout << errmsg << endl;
	}
	return 0;
}
#endif 

// 异常的重新抛出
// 有可能 单个 catch 不能完全处理一个异常，在进行一些校正处理后，希望在交给更外层的调用链来处理，catch则可以通过重新
// 抛出异常将其传递给更上层的函数进行处理.
double divide(int a, int b) {
	if (b == 0) {
		throw "Division by zeor condition";
	}
	else {
		return ((double)a / (double)b);
	}
}

void Func() {
	int len, time;
	cin >> len >> time;
	try {
		cout << divide(len, time) << endl;
	}
	catch (const char* msg) {
		cout << "dosome thing" << endl;
		throw;
	}
}

#if 0
int main() {
	try {
		Func();
	}
	catch (const char* errmsg) {
		cout << errmsg << endl;
	}
	return 0;
}
#endif 

// 异常规范：
//异常规格说明的目的是为了让函数的使用者知道函数可能抛出的异常有哪些。可以在函数的后面接 throw(异常类型) ,列出这个
// 函数可能抛出什么类型的异常.
// 函数的后面接 throw() 表示函数不抛出异常.
// 若无异常接口声明，则此函数可以抛出任何类型的异常.

// C ++ 标准库的异常体系：
// std::exception
// std::bad_alloc 
// std::bad_cast 
// ... 有很多不列举了！

#if 0
// 自定义异常体系
class Exception {
protected:
	string _errmsg;
	int _id;
};

class SqlException :protected Exception {

};

class CatchException :protected Exception {

};
class HttpException :protected Exception {

};

int main() {
	try {

	}
	catch (const Exception& e) {

	}

	return 0;
}
#endif 


// C++ 类型装换

// 1. C 语言的类型转换
// 在 C 语言中，如果赋值运算左右两侧类型不同，或者形参和实参类型不匹配，或者返回值类型与接受类型不一致时，就要发生类型转换。
// （1）隐式类型转换： 编译器在编译阶段自动进行，能转就转，不能转就编译失败。
//  (2) 显示类型转换 :自己处理的！



// 2 . C++ 四种类型转换
// why ? 隐式类型转换可能会出现精度丢失等问题。

// C++ 强制类型转换符:
 // static_cast 、 reinterpret_cast 、const_cast 、 dynamic_cast

// （1） static_cast 用于非多态类型的转换（静态转换），编译器隐式执行的任何类型转换都可以用static_cast
// 但它不能用于两个不相关类型进行转换.

void about_static_cast() {
	double d = 13.14;
	int a = static_cast<int>(d);
	cout << a << endl;
}


// (2) reinterpret_cast 操作符通常为操作数的位模式提供较低层次的重新解释，用于将一种类型转换为另一种不同的类型.
typedef void (*FUNC)();
int DoSome(int i) {
	cout << "DoSome()" << endl;
	return 0;
}

void test_reinterpret_cast() {
	FUNC f = reinterpret_cast<FUNC>(DoSome);
	f();
}


// (3) const_cast 最常用的用途就是删除变量的const属性,方便赋值！
void test_const_cast() {
	const int a = 2;
	int* p = const_cast<int*>(&a);
	*p = 3;
	cout << a << endl;
}



// dynamic_cast 用于将一个父类对象的指针/引用转换外子类对象的指针或引用。
// 向上转型： 子类对象指针/引用 -> 父类指针/引用;
// 向下转型： 父类指针/引用  ->子类对象指针/引用;
// 注意：1. dynamic_cast 只能用于含有虚函数的类。 
//		 2. dynamic_cast 会先检查是否转换成功，能成功则装换不能则返回0;

class A {
public:
	virtual void f() {};
};
class B:public A{};

void fun(A* base) {
	B* pb1 = static_cast<B*>(base);
	B* pb2 = dynamic_cast<B*>(base);

	cout << pb1 << endl;
	cout << pb2 << endl;
}
// 注意： 强制类型装换关闭或挂起了正常的类型检查。(使用的时候一定要完全确定转换无误！)

// explicit 关键字住址进过装换构造函数进行的隐式转换发生.
class X {
private:
	int _a;
public:
	explicit X(int a):_a(a){}
	X(const X& a) {
		cout << "X(const X&)" << endl;
	}
};


// RTTI :运行时类型识别！
// 利用了下面的方式支持RTTI
// 1. typeid 获取运行时对象类型;
// 2. dynamic_cast 运算符;