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)
	{}

此时报错:

C++ - 类型转换 - static_cast - reinterpret_cast - const_cast - dynamic_cast_第1张图片


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

C++ - 类型转换 - static_cast - reinterpret_cast - const_cast - dynamic_cast_第2张图片

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

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

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

C++ - 类型转换 - static_cast - reinterpret_cast - const_cast - dynamic_cast_第3张图片

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

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

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


还有下面这种情况:

C++ - 类型转换 - static_cast - reinterpret_cast - const_cast - dynamic_cast_第4张图片

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

C++ - 类型转换 - static_cast - reinterpret_cast - const_cast - dynamic_cast_第5张图片

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

	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 的输出确还是 原来的值

C++ - 类型转换 - static_cast - reinterpret_cast - const_cast - dynamic_cast_第6张图片

 这是为什么呢?

其实是编译器在此处进行了优化,因为编译器认为,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(n);

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

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

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

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

C++ - 类型转换 - static_cast - reinterpret_cast - const_cast - dynamic_cast_第7张图片

 reinterpret_cast

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

语法 是和 static_cast 是一样的:

	int b = 10;

	int* m = reinterpret_cast(b);

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

C++ - 类型转换 - static_cast - reinterpret_cast - const_cast - dynamic_cast_第8张图片

 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<

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

 dynamic_cast(动态转换)

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

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

比如现在有两个类:
 

C++ - 类型转换 - static_cast - reinterpret_cast - const_cast - dynamic_cast_第9张图片

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

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

C++ - 类型转换 - static_cast - reinterpret_cast - const_cast - dynamic_cast_第10张图片

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

C++ - 类型转换 - static_cast - reinterpret_cast - const_cast - dynamic_cast_第11张图片

 这就是向下转型

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

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 就会报错。

C++ - 类型转换 - static_cast - reinterpret_cast - const_cast - dynamic_cast_第12张图片

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

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

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

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

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

C++ - 类型转换 - static_cast - reinterpret_cast - const_cast - dynamic_cast_第13张图片

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

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

RTTI

 RTTI:Run-time Type identification的简称,即:运行时类型识别

 顾名思义,就是在运行时,识别某一个变量(对象)的类型。

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

typeid运算符(仅仅只能打印,只能看,不能用):

vector v;

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

输出:

class std::vector >

dynamic_cast运算符(识别当前要强转的对象是子类还父类):
 

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

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

 

你可能感兴趣的:(c++,开发语言)