C ++ 노트 5 유형 변환

다음 코드의 시작 코드

#include <iostream>

using namespace std;

C ++ 유형 변환

• static_cast 일반 상황
• const_cast를 상수로
• dynamic_cast 하위 클래스 유형이 상위 유형으로 변환됩니다.
• reinterpret_cast 함수 포인터 변환, 이식 가능하지 않음

원래 유형 변환, 모든 경우가 방식으로 작성되고 가독성이 높지 않으며 잠재적 위험이있을 수 있습니다.

static_cast

void* func(int type){	
	switch (type){
	case 1:	{
				int i = 9;
				return &i;
	}
	case 2:	{
				int a = 'X';
				return &a;
	}
	default:{
				return NULL;
	}

	}	
}

void func2(char* c_p){
	cout << *c_p << endl;
}

void main(){	
	//int i = 0;
	//自动转换
	//double d = i;
	//double d = 9.5;
	//int i = d;

	//int i = 8;
	//double d = 9.5;
	//i = static_cast<int>(d);
	
	//void* -> char*
	//char* c_p = (char*)func(2);
	//char* c_p = static_cast<char*>(func(2));

	//C++ 意图明显
	func2(static_cast<char*>(func(2)));
	//C
	func2((char*)(func(2)));
	
	system("pause");
}

---

const_cast를 상수로

void func(const char c[]){
	//c[1] = 'a';
	//通过指针间接赋值
	//其他人并不知道，这次转型是为了去常量
	//char* c_p = (char*)c;
	//c_p[1] = 'X';
	//提高了可读性
	char* c_p = const_cast<char*>(c);
	c_p[1] = 'Y';

	cout << c << endl;
}

void main(){
	char c[] = "hello";
	func(c);

	system("pause");
}

---

dynamic_cast 하위 클래스 유형이 상위 유형으로 변환됩니다.

class Person{
public:
	virtual void print(){
		cout << "人" << endl;
	}
};

class Man : public Person{
public:
	void print(){
		cout << "男人" << endl;
	}

	void chasing(){
		cout << "泡妞" << endl;
	}
};


class Woman : public Person{
public:
	void print(){
		cout << "女人" << endl;
	}

	void carebaby(){
		cout << "生孩子" << endl;
	}
};

void func(Person* obj){	

	//调用子类的特有的函数，转为实际类型
	//并不知道转型失败
	//Man* m = (Man*)obj;
	//m->print();

	//转型失败，返回NULL
	Man* m = dynamic_cast<Man*>(obj);	
	if (m != NULL){
		m->chasing();
	}

	Woman* w = dynamic_cast<Woman*>(obj);
	if (w != NULL){
		w->carebaby();
	}
}

void main(){
	
	//Woman w1;
	//Person *p1 = &w1;

	//func(p1);

	Woman w1;
	Woman* w_p = &w1;
	

	system("pause");
}

---

reinterpret_cast 함수 포인터 변환, 이식 가능하지 않음

이식 불가능 : 일부 컴파일러는이를 지원하지 않을 수 있습니다.
reinterpret_cast의 가장 일반적인 용도는 "함수 포인터"유형을 변환하는 것입니다. 특정 유형을 가진 함수 포인터를 저장하는 배열이 있다고 가정하십시오.

void func1(){
	cout << "func1" << endl;
}

char* func2(){
	cout << "func2" << endl;
	return "abc";
}

typedef void(*f_p)();

void main(){
	//函数指针数组
	f_p f_array[6];
	//赋值
	f_array[0] = func1;

	//C方式
	//f_array[1] = (f_p)(func2);
	//C++方式
	f_array[1] = reinterpret_cast<f_p>(func2);

	f_array[1]();

	system("pause");
}

typedef void (* FuncPtr) (); // FuncPtr은 함수를 가리키는 포인터이며,이 함수는 void (함수 포인터)를 반환합니다.