C++进阶STL-类型转化

1. static_cast: 普通内置数据类型之间转化，具有继承关系之间的指针或者引用之间的转化

class Building{};
class Animal{};
class Cat:public Animal{};




//int -> char
	int a = 97;
	char c = static_cast<char>(a);
	cout << c << endl;

//int*  ->  char*       普通类型指针(无效)
//	int* pInt = NULL;
//	char* pChar = static_cast<char*>(pInt);


//不同类指针之间的转化             (无效)
//	Building* pBuilding1 = NULL;
 //       Animal* pAnimal1 = static_cast<Animal*>(pBuilding1);


// 子类指针->父类指针
	Cat* pCat2=NULL;
	Animal*pAnima2 = static_cast<Animal*>(pCat2);
    

// 父类指针->子类指针
	Animal* pAnimal3 = NULL;
	Cat* pCat3 = static_cast<Cat*>(pAnimal3);

// 子类引用-> 父类引用
	Cat cat4;
	Cat& yCat4 = cat4;
	Animal& yAnimal4 = static_cast<Animal&> (yCat4);
// 父类引用 -> 子类引用
	Animal animal5;
	Animal& yanimal5 = animal5;
	Cat& ycat5 = static_cast<Cat&> (yanimal5);

	
	
	

2. dynamic_cast : 具有继承关系的指针或者引用之间的转化，并且进行严格的检查，只能从子转父。

class Building{};
class Animal{};
class Cat:public Animal{};

	//不同类指针之间的转化             (无效)
	//Building * pBuilding1 = NULL;
       //Animal * pAnimal1 = dynamic_cast<Animal*>(pBuilding1);


	// 父类引用 -> 子类引用            (无效)
	//Animal animal5;
	//Animal& yanimal5 = animal5;
	//Cat& ycat5 = dynamic_cast<Cat&> (yanimal5);


	// 父类指针->子类指针               (无效)
	//Animal* pAnimal3 = NULL;
	//Cat* pCat3 = dynamic_cast<Cat*>(pAnimal3);
	

	// 子类引用-> 父类引用
	Cat cat4;
	Cat& yCat4 = cat4;
	Animal& yAnimal4 = dynamic_cast<Animal&> (yCat4);
	
	
		// 子类指针->父类指针  
	Cat* pCat2 = NULL;
	Animal*pAnima2 = dynamic_cast<Animal*>(pCat2);

	

3. const_cast: 增加或去除变量的 const 性

// 引用
	int a = 10;
	const int &b= a;  //不可以通过 b 去修改 a
    
	情况(1) //编译器报错
	     int &c=b;   
		 
	
	情况(2) //这样就可以通过c修改 a 和  b
	    int &c=const_cast<int &>(b);
	    c = 11;


//指针

    //const -> none const
        const int* p1 = NULL;
	int *p2 = p1;       (无效)，//不可用const int* 型去初始化 int*

	int*p3= const_cast<int*>(p1);  //OK
	


    //none const-> const
	int* p1 = NULL;
	const int *p2 = const_cast<const int*>(p1);

4. reinterpret_cast: 任何指针类型之间的转化(包括函数指针)

class Building{};
class Animal{};
class Cat:public Animal{};


//  不同类指针之间的转化
        Building* B1;
	Animal* A1;
	A1 = reinterpret_cast<Animal*>(B1);
	
	
//	函数指针之间转化
	typedef void (FUNC1)(int, int);
        typedef void (FUNC2)(int, char);
	
	FUNC1*  pfun1=NULL;
	FUNC2*  pfun2 = reinterpret_cast<FUNC2* >(pfun1);