C++ - 类型转换 - static_cast - reinterpret_cast - const_cast - dynamic_cast

目录

类型转换

C语言当中的类型转换

为什么C++需要四种类型转换 （讲解volatile关键字）

C++强制类型转换 

static_cast

 reinterpret_cast

 const_cast 

 dynamic_cast（动态转换）

RTTI

---

类型转换

C语言当中的类型转换

其实在 C语言当中就已经有了类型转换，只要是 赋值运算符的左右两侧的类型不同，或者是形参与实参的类型不匹配，还有返回值和接受返回值的类型不一样时，就会发生类型转换。 

 在C 语言当中，总共有两种类型转换方式：

隐式类型转换：编译器在编译时期自动进行，如果能转换就转换，如果不能转换就报错。

显示类型转换（强制类型转换）：需要用户自己进行处理。

void Test()
{
	int i = 1;
	// 隐式类型转换
	double d = i;

	printf("%d, %.2f\n", i, d);

	int* p = &i;
	// 显示的强制类型转换
	int address = (int)p;

	printf("%x, %d\n", p, address);
}

对于相似类型，或者说是意义相近的类型，可能进行隐式类型转换。

 比如：像 double ，int ， char  ， shrot 等等这些整形家族是可以发生隐式类型转换的；整形 和 指针类型也是可以的，因为 指针存储的是地址，地址是编号，是 四个字节存储的十六进制的数。

还有，单参数的构造函数 也支持隐式类型转换。 

class A
{
public:
	A(int a = 1)
		:_a(a)
	{}

private:
	int _a;
};

class B
{
public:
	B(const A& a)
	{}
private:
	//....
};

int main()
{
	A a;
	a = 1;  // 此时也是 发生 隐式类型转换
            // 由 int 转换为 A

	B b = a; // 此处发生隐式类型转换
	// 本来是 拷贝 + 拷贝构造
	// 由a 构造一个 A 类型的临时对象
	// 由这个临时对象拷贝构造个 b 这个对象
	// 但是编译器在这里进行优化，由 a 直接构造了 b

	return 0;
}

上述两者都是，构造 + 拷贝构造，由赋值运算符右边的数据类型，构造一个 赋值赋值运算符左边的 自定义类型的临时变量，然后由这个临时变量 拷贝构造 给 左边的 自定义类型变量。 

 如果，你不想在此发生隐式类型转换，你可以把 单参数的 构造函数用 explicit 关键词修饰：
 

	explicit A(int a = 1)
		:_a(a)
	{}

此时报错：

---

只要是有点关联的类型之间，一般是可以发生隐式类型转换的；如果是完全没有关联的话，是不能发生隐式类型转换的，例如：string 和 vector<int> 这两者之间是完全没有关联的，不能发生隐式类型转换。

 而，对于强制类型转换，就都可以转换了。

为什么C++需要四种类型转换 （讲解volatile关键字）
 

隐式类型转换 是会带来很多坑的，比如下面这个代码：
 

 在while 循环条件当中，end 是int 类型，pos 是 size_t 类型，就会发生隐式类型转换，转换为 size_t 类型，一般这种转换是 小类型转换为 大类型，比如 如果是 int 和 double 就是 int 转换为 double 类型，在下述博客 的 "增" 这一章节当中，insert（）函数的实现就遇到了这个问题，在下述博客当中介绍的更详细：

C++-string类的模拟实现_chihiro1122的博客-CSDN博客

 那么，在上述这个问题，有了隐式类型转换之后，机会造成误解，如果不支持的话，那么while 当中的条件肯定是会报错的，我们一眼就能看出错误，但是有了隐式类型转换就不一定了。

---

还有下面这种情况：

 上述的 n 不是常量，n是常变量。常变量不能直接修改，当然也不能直接被指针引用：

 只能间接修改 或者间接被指针引用：
 

	int* pn = (int*)&n;
	*pn++;

 上述是可以编译通过的。

那么，你可以猜一猜下述的代码输出的是什么：

	const int n = 10;
	
	int* pn = (int*)&n;
	(*pn)++;

	cout << n << endl;
	cout << *pn << endl;

 不是 10 10 和 11 11 ，结果如下：

10
11

此时你可能会认为，pn 指向的变量 和 n 已经不是一个变量了，其实不是，当我们输出两个地址，发现还是一个地址：
 

	const int n = 10;
	
	int* pn = (int*)&n;
	(*pn)++;

	cout << &n << endl;
	cout << pn << endl;

输出结果：

0000002134EFF984
0000002134EFF984

 如果你不服，再去逐步调试，发现，其实 pn 指针的修改确实是影响到了 n 的值，但是 n 的输出确还是 原来的值：

 这是为什么呢？

其实是编译器在此处进行了优化，因为编译器认为，const 变量是不能进行修改的，没有在内存当中取 n 的数据，把 n 实际的值放到了 寄存器当中，当我们访问 n 的值的时候是直接从寄存区当中去取 n 的值的。

关于常变量的取出，你可以理解为 从 寄存器当中取值，然后进行了类似宏替换的操作（但是实际上不是宏替换）。 

如果你不想让编译器从 寄存器当中取数据，来替换的话，可以使用 volatile 这个关键字修饰 n 这个变量，告诉编译器，直接从内存当中去取 n 的值。

我们要记住的是，修改一个 常变量的 const 属性是要 背上风险的，就像上述一样，pn 指针是能修改到 n 的值，但是 在访问 n 的 时候 n 的值还是没变。类似 (int*)&n 这样的操作是会有安全隐患的。

---

总结一下：

C风格的转换格式很简单，但是有不少缺点的：

•  隐式类型转化有些情况下可能会出问题：比如数据精度丢失。
•  显式类型转换将所有情况混合在一起，代码不够清晰。

因此C++提出了自己的类型转化风格，注意因为C++要兼容C语言，所以C++中还可以使用C语言的转化风格。
 

C++强制类型转换 

 在 C++ 当中对 强制类型转换进行了 四种归类，引入了四种命名的强制类型转换操作符：

static_cast

reinterpret_cast

const_cast

dynamic_cast

C++ 当中期望你在对类型转换的时候，进行规范的转换。 

static_cast

当你在进行 相近类型，或者是意思相近类型转换，也就是在 C 当中的隐式类型转换，期望你用 static_cast 关键字来进行转换：

static_cast 语法（关于语法我们直接举例来说明）：

	double n = 10;

	int m = static_cast<int>(n);

向上述情况就是把 double 类型的 n 强转为 int 类型，从而被 int 类型的 m 变量所接收。

需要注意区分的是：括号说要扩在 被强转类型的变上面的，而不是 static_cast 本身，不是像之前强转一样 （int*）n 这种方式，使用在 static_cast 上面是错误的，如下面的错误示范：

int m = (static_cast<int>)n; // 这种方式是错误的写法

---

不是相近类型，不要用 static_cast 来转换，会报错：
 

 reinterpret_cast

 reinterpret_cast 就可以实现 不相关类型，不相近类型之间的类型转换。reinterpret_cast操作符通常为操作数的位模式提供较低层次的重新解释来实现。

语法 是和 static_cast 是一样的：

	int b = 10;

	int* m = reinterpret_cast<int*>(b);

这种不相关类型之间的 转换 关键字（reinterpret_cast） ，是不处理 上述 const int n = 10 的强制类型转换的，这里编译器进行了强制的识别，直接报错：

 const_cast 

对于 const int n = 10; (int*)&n;  这种方式的强制类型转换，需要用 const_cast 关键字来实现，用上述的 reinterpret_cast 是不行的。 

 const_cast最常用的用途就是删除变量的const属性，方便赋值。

 语法都是一样的：

const int a = 2;
int* p = const_cast< int*>(&a );
*p = 3;

cout<<a <<endl;

但是，即便是上述的方式，也是修改了 const 变量的 const 属性，所以还是有风险的，要用 volatile 关键词修饰。

 dynamic_cast（动态转换）

 dynamic_cast 用于将一个 父类对象的指针/引用 转换为 子类对象的指针或引用(动态转换)

 在了解什么是 动态转换之前，我们先来了解一下什么是 向上转型 和 向下转型：

比如现在有两个类：
 

 如果是 ptra = ptrb 的话，就是把 子类对象指针 赋值给 父类对象指针，此时就是向上转型，此时就会发生隐式类型转换，父类发生赋值兼容规则，也就是切片，从而可以接收到 子类当中父类那部分的数据。

 如果是 ptrb = ptra 的话，就是把 父类对象指针 赋值给 子类对象指针，如果是直接赋值的话是不行的，会报错：

 此时我们可以利用 C 当中指针之间可以进行强转的规则，来对 ptra 来进行类型的强转，就可以实现 把 父类对象指针 赋值给 子类对象指针。

 这就是向下转型。

但是，向下转型是不安全的。如下例子所示：

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

	int _x = 0;
};

class B : public A
{
public:
	int _y = 0;
};

void fun(A* pa)
{
	B* pb = (B*)pa;
	pb->_x++;
	pb->_y++;
}

int main()
{
	A aa;
	fun(&aa);

	return 0;
}

如上，在 fun（）函数当中，参数类型用的是 A类对象指针，在函数当中，对 传入的 A类对象指针进行了 强制转换，使得 pb 能够接受到 pa。

此时，如果 fun（）函数在外部传入的是一个 B 类对象，那么是没问题的，此时 pa 指针大小就是 8 个字节的大小去访问，pb就可以访问到 pa 当中的_x 成员变量了。因为 pa 此时是B类指针类型，B 类是一个子类，其中是有父类的对象加上子类B自己对象空间，也就是说，在B对象当中是存储得有 A类对象的。那么在 pa 指向的B类对象当中  _x 和 _y 是都有的。

但是fun（）函数在外部传入的是一个 A类对象指针，此时 pa 指针大小就是 4 个字节的大小去访问，此时 pb 就会按照 他的指针指向的类型大小去看，就会访问 8 个字节，但是实际上 pa 指向的类型大小就是 4个字节，此时就是访问越界，那么pa 指向这个A类对象，这个A类对象当中是只有 _x 的，没有 _y 。所以在fun（）函数的当中访问到 _y 就会报错。

如果是 传入 的是一个 A类对象 这种情况，就会发生越界，或者说是找不到 _y 的问题。

 此时，我们可以用 dyonamic_cast 来解决问题，他会帮助我们去判断，要转换的类型是处于上述两种情况的哪一种，如果是第一种，那么就可以强制转换，向上述例子就是正常返回地址；如果是第二种不行了，返回一个 nullptr 指针。

 所以，此时，就上述例子，我们可以进行一下修改：
 

void fun(A* pa)
{
	// pa是指向子类对象B的，转换可以成功，正常返回地址
	// pa是指向父类对象A的，转换失败，返回空指针
	B* pb = dynamic_cast<B*>(pa);
	if (pb)
	{
		cout << "转换成功" << endl;
		pb->_x++;
		pb->_y++;
	}
	else
	{
		cout << "转换失败" << endl;
	}
}

关于 dynamic_cast 是如何实现的，其实是在 对象当中做了标记，我们可以简单的做一些实验，我们把 父类 A当中的 虚函数给变成普通函数，就会编译报错：

 不是多态，就说明父类没有虚函数，也就没有虚函数表，只要有虚函数表，dynamic_cast 才能在虚表当中进行标记。在转换 pa 的时候，就会去虚函数表当中去检测 pa 指向的对象是子类还是父类。

在使用 dynamic_cast 转换的话，此时向下转型是安全的了。

RTTI

 RTTI：Run-time Type identification的简称，即：运行时类型识别。

 顾名思义，就是在运行时，识别某一个变量（对象）的类型。

在 C++ 当中可以用以下的方式支持 RTTI：

typeid运算符（仅仅只能打印，只能看，不能用）：

vector<int> v;

cout << typeid(v).name() << endl;

输出：

class std::vector<int,class std::allocator<int> >

dynamic_cast运算符（识别当前要强转的对象是子类还父类）：
 

// 如上述使用的例子
B* pb = dynamic_cast<B*>(pa);

decltype，取到某变量，或者某对象的类型，这个类型是可以使用的，我们可以使用这个类型来创建变量，函数传参，函数返回值接收等等操作：