C++ 的强制类型转换

news2024/11/15 10:53:35

C++ 的强制类型转换

目录(转换方式):

1 、static_cast

2 、dynamic_cast

3、reinterpret_cast

4、const_cast

5、类型转换使用建议

一、 static_cast：用于基本类型之间的转换

static_cast<>() 可以说是神通广大。

使用方法： type y = static_cast< type >( expression );

// type-> 需要转换成的目标类型
// expression -> 需要转换的变量或者表达式
//1、基本类型的转化
int age = 100;
double age1=static_cast< double >( age ); //将 int类型转换成 double

//2、父子类之间的转换   class Dog 继承至 class animal
Dog *dog1=new Dog();
Animal *al=static_cast<Animal *>(dog1);  //之类性转换成父类型
Dog *dog1=static_cast<Dog *>(al);   //父类型的指针到子类的指针（父类到子类有风险）

Dog dog2;
Animal &a2=static_cast<Animal &>(dog2); //之类性转换成父类型
Dog &dog2=static_cast<Dog &>(a2);      //父类型的引用到子类的引用（父类到子类有风险）

// 3、把空指针转换成目标类型的空指针
int *p=static_cast<int *>(NULL);
Dog *dog=static_cast<Dog*>(NULL);

// 4、把任何类型的表达式转换成void类型
int *p=new int[19];
void *vp=static_cast<void *>(p);
vp=p;

常见的基本数据类型：

整数类型（int）：用于表示整数，包括正整数、负整数和零。
浮点数类型（float和double）：用于表示实数，即带有小数点的数。
字符类型（char）：用于表示单个字符，可以是字母、数字、符号等。
布尔类型（bool）：用于表示真或假、是或否等。

使用时的陷阱：

1、static_cast : 可以用于类的上下转型。但是，这种转换方式没有运行时检查，因此可能会导致安全问题。

2、static_cast不能转换掉表达式的const、volatile或unaligned属性。如果需要改变这些属性，需要考虑其他类型的转换或使用方法。

二、 dynamic_cast 用于类之间的上下转型

dynamic_cast 主要用于实现多态性，通过基类的指针或引用来调用派生类的成员函数。

dynamic_cast ->如果类型转换失败返回 NULL

说明: nullptr 和 NULL在C++中都用于表示空指针,那么两者有何区别

nullptr 是C++11新引入的 ,nullptr的含义更加明确，它专门用于表示空指针，没有其他的含义，更安全。
NULL在C++中通常被定义为整型常量，需要隐式地转换为指针类型。

使用方式： type y = dynamic_cast< 目标类型 >( 源指针 )*

#include<iostream>
#include<string>

using namespace std;

class Test {
public:
	//构造函数
	Test(int age = 12, string name = " 吴献丰 ") {
		age_ = age;
		name_ = name;
	}
	virtual void paly() {
		cout << "一起去玩吗?" << endl;
	}
	//析构函数
	~Test()  { }
protected:
	int age_;
	string name_;
};

class Test2 : public Test {
public:
	Test2(string name) {
		name_ = name;
	}
	void paly() {
		cout << "一起去吃汉堡王吗?" << endl;
	}
	Test2() {  }
private:
	string addr_;
};

int main() {
	Test2 *test2 = new Test2( "重庆秀山" );

	// dynamic_cast  ->如果类型转换失败 返回 NULL
	Test *test = dynamic_cast< Test * > ( test2 );

	if (test == NULL) {
		cout << "类型转换失败: " << endl;
	}else {
		test->paly(); //这里调用的是 派生类的 paly方法->输出一起去吃汉堡王吗?
	}

	return 0;
}

无效的转换：基类 -》派生类

//  Test2  继承至 Test 
Test* test = new Test();
Test2 *test2 = new Test2();

Test2 *t = dynamic_cast< Test2 * > ( test );
Test2* t = dynamic_cast<Test2*>(test);
if (t == NULL) {
	cout << "类型转换失败" << endl;  //程序运行后会输出这句话
}

为什么要使用 dynamic_cast :

1、可以使用基类指针来操作不同类型的对象，而无需知道对象的具体类型。

2、实现基类和派生类的安全转换。如果转换成功，我们可以通过基类的指针来访问派生类的方法。

三、reinterpret_cast 常用于不同类型指针之间的强制转换，甚至是将指针转换成整数.

使用方式： type y = reinterpret_cast< type >( expression )

// type-> 需要转换成的目标类型
// expression -> 需要转换的变量或者表达式

Demo : 常见的几种用法

1 、指针之间的转换：例如将int指针转换为char指针。

int x = 10;  
int* int_ptr = &x;  
char* char_ptr = reinterpret_cast<char*>(int_ptr);

2、指针与整数之间的转换：可以指针转换为整数类型，或将整数类型转换为指针。

int x = 10;  
int* int_ptr = &x;  
int int_val = reinterpret_cast<int>(int_ptr);

注意：

这种转换方式没有进行类型检查，因此风险较高。

四、const_cast 主要用于去除对象的常量性限制，或者添加常量性限制

将const对象转换成非const对象进行修改。

使用方式：

type y = const_cast< type >( expression )

举例说明：

int a = 3;  
const int *b = &a;      // b是一个指向常量的指针，不能通过b修改a的值  
int* c = const_cast<int*>(b); // 使用const_cast去除b的const属性，得到指向非常量的指针c  
*c = 4;                // 通过c修改a的值  
cout << a << *c;        // 输出两个4，表明a的值已经被修改

补充：对于 const的位置，起到的作用

const 加在最前面 : const int *age = &a; // age 所指向的地址的内容不能被改变。
const 加在后面： int * const age=&a; // age 的值（也就是它所指向的地址）在初始化后不能再被改变。也就是说age只能指向a。
const 加在前后： const int * const age = &a; //age 所指向的地址的内容不能被改变 , 同时 age 只能指向a, 指向其他变量的地址会报错。也就是说 age 的值和它所指向的地址的内容都不能被改变。