volatile关键字及C++数据类型转换

1. reinterpret_cast并不在类的层次中穿行，即不关心继承体系。
2. reinterpret_cast用于任意类型的转换，当然和其它强制类型一样，存在安全性。
3. reinterpret_cast不会强制去掉const。
4. reinterpret_cast后的尖括号中的类型是一个指针、引用、算术类型、函数指针或者成员指针。它可以把一个指针转成一个整数，也可以把一个整数转换成一个指针。

学习资料：https://blog.csdn.net/liranke/article/details/5423378

const_cast用于删除变量的const属性，方便赋值。

int main()
{
    int variable = 10;
	int* constP = &variable;
	int* modifier = const_cast(constP);

	*modifier = 20;
	cout << "*modifier = " << *modifier << endl;
	cout << "modifier = " << modifier << endl;
	cout << "*constP = " << *constP << endl;
	cout << "constP = " << constP << endl;
	cout << "variable = " << variable << endl;
	
    return 0;
}

  分析：

  以上代码，通过modifier指针对variable进行了值的修改。

  我们定义了一个非const的变量，但用带const限定的指针去指向它，在某一处我们突然又想修改了，可是我们当前场景下只有指针，这时我们可以用const_cast来修改。

  例子如下：

int a = 20;
const int* const p = &a;
int* const p1 = const_cast(p);
*p1 = 21;
cout << a << endl;//21·

  在看一个例子：

void output(int* val)
{
	cout << val << endl;
}

int main()
{
	const int i = 20;
	const int* p = &i;
	cout << p << endl;//输出：012FF934
	//output(p);//fail
	output(const_cast(p));//输出：012FF934
	return 0;
}

  分析，定义了常量i，以及常量指针p，将p作为参数传递给output函数，结果编译失败；

  使用const_cast以后，将i的地址去除const后，传递给output函数，编译正常运行；

  可见，const_cast的主要作用是去除const。

学习资料：https://blog.csdn.net/liranke/article/details/5145787

用于将一个父类对象的指针或引用转换为子类对象的指针或引用。（动态交换）必须包含一个多态类型（虚函数）。

class A
{
	int a;
	virtual void func() {}
};

class B :public A { int b; };

class C :public A { int c; };

int main()
{
	B b;
	A* a = dynamic_cast(&b);

	if (nullptr == a)
		cout << "error" << endl;
	else
		cout << "success" << endl;//输出：success，子类转换为父类成功

	C* c = dynamic_cast(a);
	if (nullptr == c)
		cout << "error" << endl;//输出：error，父类转换为子类失败
	else
		cout << "success" << endl;
    return 0;
}

//美术家
class Artist
{
	public:
		virtual void draw() { cout << "Artist draw" << endl; }
};


//音乐家
class Musician
{
	public:
};


//教师
class Teacher
{
	public:
		virtual void teachStu() { cout << "Teacher teachStu" << endl; }
};

//既是美术家，又是音乐家，同时是教师的人
class People :public virtual Artist, public virtual Musician, public Teacher
{
	public:
};

int main()
{
	People* p1 = new People();
	p1->draw();
	p1->teachStu();
	cout << "dynamic_cast" << endl;

	Artist* a1 = dynamic_cast(p1);//success
	//Artist* a1 = p1;//success，向上转换，C++总是能正确识别，即将派生类的指针赋值给基类指针
	
	a1->draw();//success
	//a1->teachStu();//fail
	return 0;
}

说明：

1. 继承关系：People继承自Artist、Musician、Teacher三个类
2. 语义：Artist美术家、Musician音乐家、Teacher教师。

People类：定义一个特殊的People类，它的特点都是：既是美术家，又是音乐家，同时是教师。

上面的代码，运行结果如下：

Artist draw
Teacher teachStu
dynamic_cast
Artist draw

分析：

下面两条语句均正确，都能由子类People转化为父类Artist。并且调用父类Artist的成员函数均能成功。

Artist *a1 =  dynamic_cast(p1); 等价于 Artist *a1 =  p1; 
a1->draw();     //success: 打印people teachStu

可见，向上转换，无论是否用dynamic_cast，C++总是能够正确识别，即将派生类的指针赋值给基类指针。

void test1()
{
    People* p1 = new People();
	printf("dynamic_cast test:n");
	Artist* a1 = p1;//success
	//People* p2 = (People*)a1;//fail
	People* p3 = dynamic_cast(a1);	//success
	p3->draw();
	p3->teachStu();
}

分析：

1. People *p2 = (People*)a1;明确说明，无法直接用(T*)b的形式去进行由基类指针到派生类指针的转换。
2. People *p3 = dynamic_cast(a1);添加动态强制类型转换即可。

  由基类到派生类指针的转换通过dynamic_cast来完成。

  那么为什么使用dynamic_cast，基类指针a1就能转换为派生类指针p3呢？

  这就是RTTI机制。

  RTTI：Run Time Type Identification，即通过运行时类型识别。程序能够使用基类的指针或引用来检查这些指针或引用所指向对象实际的派生类型。

  C++提供在RTTI机制中逻辑上，存在类似如下的内存模型图：

  在这个内存模型中，每个类都会在内存中保存一份类型信息，编译器会将存在继承关系的类的类型信息使用指针“连接”起来，从而形成一个继承链（Inheritance Chain）。

  dynamic_cast的使用注意事项：

1. 查找规则：当使用dynamic_cast对指针或引用类型进行类型转换时，会先找到要转换目标指针指向的对象，再根据对象找到当前类（指针或引用指向的对象类型）的类型信息，并从此节点开始沿着继承链向上遍历（注意是向上），如果找到了要转换的目标类型，那么说明这种转换是安全的，就能够转换成功，如果没有找到要转换的目标类型，那么说明这种转换存在较大风险，不能够转换（返回nullptr）。
2. 作用对象：注意dynamic_cast转换符只能用于含有虚函数的类。

  现在，用RTTI来解释test1()中的函数代码：

  p1是派生类指针，a1是基类指针，a1要转换的指针类型为People，根据RTTI机制，从类People类向上查找，能找到a1所指的类Artist，所以，dynamic_cast转换是合法的。

void test2()
{
    People* p1 = new People();
	printf("dynamic_cast test:n");
	Musician* m1 = p1;//success
	//People* p2 = (People*)m1;//fail
	//People* p3 = dynamic_cast(m1);//fail
}

分析：

  根据dynamic_cast使用注意事项中“dynamic_cast”转换符只能用于含有虚函数的类（虚基类），Musician是非虚基类，所以无法进行动态强制转换。

void test3() {
	People *p1 = new People();
	printf("ndynamic_cast test:n");
	Teacher *t1 = p1; //success
	People *p2 = (People*)t1;//success,继承自Teacher，采用非虚继承的方式（不使用virtual），所以ok。
	People *p3 = dynamic_cast(t1);//success：加了dynamic_cast，进行强转
}

分析：

1. People *p2 = (People*)t1; People继承自Teacher，而采用非虚继承的方式，成功，因为采用的是非虚继承；
2. People *p3 = dynamic_cast(t1); 加了dynamic_cast，进行强转，成功，因为Teacher是虚基类，而且符合RTTI机制。