目录
一 C 强制类型转换
在C语言中,如果赋值运算符左右两侧类型不同,或者形参与实参类型不匹配,或者返回值类型与 接收返回值类型不一致时,就需要发生类型转化,C语言中总共有两种形式的类型转换:隐式类型 转换和显式类型转换。
1. 隐式类型转化:编译器在编译阶段自动进行,能转就转,不能转就编译失败
2. 显式类型转化:需要用户自己处理
void Test()
{
int i = 1;
// 隐式类型转换
double d = i;
printf("%d, %f\n", i, d);
int* p = &i;
// 显示的强制类型转换
int address = (int)p;
printf("%x, %d\n", p, address);
}
缺陷: 转换的可视性比较差,所有的转换形式都是以一种相同形式书写,难以跟踪错误的转换
二 C++ 强制类型转换
标准C++为了加强类型转换的可视性,引入了四种命名的强制类型转换操作符:
static_cast、reinterpret_cast、const_cast、dynamic_cast
1 static_cast
static_cast用于非多态类型的转换(静态转换),编译器隐式执行的任何类型转换都可用 static_cast,但它不能用于两个不相关的类型进行转换
int main()
{
// 建议规范,但是以前的还能用
double d = 12.34;
int a1 = static_cast<int>(d);
cout << a1 << endl;
int a2 = d;
cout << a2 << endl;
return 0;
}
2 reinterpret_cast
reinterpret_cast操作符通常为操作数的位模式提供较低层次的重新解释,用于将一种类型转换 为另一种不同的类型
int main()
{
double d = 12.34;
int a = static_cast<int>(d);
cout << a << endl;
// 对应的是以前的强制类型转换
//int* p = static_cast<int*>(a); 报错
int* p = reinterpret_cast<int*>(a);
cout << p << endl;
}
3 const_cast
const_cast最常用的用途就是删除变量的const属性,方便赋值
int main()
{
//const int a1 = 2; //-->不加 volatile 最后结果a1 还是2
volatile const int a1 = 2;// volatile 指出 a1 是随时可能发生变化的,每次使用它的时候必须从 a1 的地址中读取
//int* p1 = (int*)&a1;
int* p1 = const_cast<int*>(&a1);
*p1 = 3;
cout << a1 << endl;
cout << *p1 << endl;
return 0;
}
4 dynamic_cast
dynamic_cast用于将一个父类对象的指针 / 引用转换为子类对象的指针或引用(动态转换)
向上转型:子类对象/指针 / 引用->父类指针 / 引用(不需要转换,赋值兼容规则)
向下转型:父类对象/指针 / 引用->子类指针 / 引用(用dynamic_cast转型是安全的)
注意:
1. dynamic_cast只能用于父类含有虚函数的类
2. dynamic_cast会先检查是否能转换成功,能成功则转换,不能则返回0
class A
{
public:
virtual void f() {}
int _a = 0;
};
class B : public A
{
public:
int _b = 1;
};
void fun(A* pa)
{
// 向下转换:父->子
// pa指向子类对象,转回子类,是安全的
// pa指向父类对象,转回子类,是不安全的,存在越界的风险问题
// 不安全
//B* pb = (B*)pa;
// pa指向子类对象,转回子类,正常转换
// pa指向父类对象,转回子类,转换失败
B* pb = dynamic_cast<B*>(pa);
if (pb)
{
cout << pb << endl;
cout << pb->_a << endl;
cout << pb->_b << endl;
}
else
{
cout << "转换失败" << endl;
}
}
int main()
{
A a;
B b;
fun(&a);
fun(&b);
return 0;
}
注意 强制类型转换关闭或挂起了正常的类型检查,每次使用强制类型转换前,应该仔细考虑是 否还有其他不同的方法达到同一目的,如果非强制类型转换不可,则应限制强制转换值的作用 域,以减少发生错误的机会。强烈建议:避免使用强制类型转换
5 RTTI
RTTI:Run - time Type identification的简称,即:运行时类型识别。
C++通过以下方式来支持RTTI:
1. typeid运算符
#include <typeinfo>
class Base {};
class Derived : public Base {};
int main() {
Base* p = new Derived();
std::cout << typeid(*p).name() << std::endl; // 输出对象的实际类型
delete p;
return 0;
}
class Base { virtual void func() {}; };
class Derived : public Base {};
int main() {
Base* p = new Derived();
std::cout << typeid(*p).name() << std::endl; // 输出对象的实际类型
delete p;
return 0;
}
-
没有虚函数时:如果
Base
类没有虚函数,编译器无法生成虚表(vtable),也就无法保存派生类的实际类型信息。因此,在没有虚函数的情况下,typeid(*p)
会返回Base
的类型,而不会识别p
实际指向的Derived
类型。在没有多态的类层次中,typeid
只能得到指针或引用的静态类型(声明类型)。 -
有虚函数时:如果
Base
包含虚函数,编译器会为每个派生类生成一个虚表,其中包含了派生类的类型信息。因此,typeid(*p)
可以利用虚表中的信息在运行时识别p
的实际类型。
2. dynamic_cast运算符
#include <iostream>
class Base {
virtual void func() {} // 必须有虚函数才能使用 RTTI
};
class Derived : public Base {};
int main() {
Base* p = new Derived();
if (Derived* dp = dynamic_cast<Derived*>(p)) {
std::cout << "Conversion succeeded." << std::endl;
}
else {
std::cout << "Conversion failed." << std::endl;
}
Base* b = new Base();
if (Derived* d = dynamic_cast<Derived*>(b)) {
std::cout << "Conversion succeeded." << std::endl;
}
else {
std::cout << "Conversion failed." << std::endl;
}
delete p;
delete b;
return 0;
}
b
实际上指向一个 Base
类型的对象,而不是 Derived
类型。因此,dynamic_cast<Derived*>(b)
不能成功,因为 b
不指向 Derived
或 Derived
的子类对象,这种情况下,dynamic_cast
返回 nullptr
,导致 "Conversion failed." 的输出。
只有当 Base*
实际上指向一个 Derived
对象时,转换才会成功
3. 区分decltype
decltype
确实存在并且与 RTTI(运行时类型信息)不同。虽然它可以用来获取变量或表达式的类型,但它是在编译时进行类型推断的,而不是在运行时。
decltype
用于在编译时确定表达式或变量的类型。它不会在运行时检查对象的实际类型,而是直接返回其类型信息。在 C++ 中,可以使用 decltype
获取任意变量、表达式或函数返回值的静态类型。
class Base {
virtual void func() {}
};
class Derived : public Base {};
int main() {
Derived d;
Base* p = &d;
decltype(p) newPtr; // newPtr 的类型是 Base*,而不是 Derived*
std::cout << typeid(newPtr).name() << std::endl; // 输出 Base*
// typeid 使用 RTTI 获取实际类型,返回 Derived 类型信息
std::cout << typeid(*p).name() << std::endl; // 输出 Derived 类型
return 0;
}
三 类型之间的关联性
有一定关联的类型才可以互相转换
1 C
1 整形之间 隐式类型转换
2 整形和浮点数 隐式类型转换
3 bool和整形 bool和指针 隐式类型转换
4 指针和整形 强制类型转换
5 不同类型的指针之间 强制类型转换
int i = 1;
int* p = &i;
//double dd = (double)p; -->无法转换,他们之间没有关联
2 CPP
1. 内置类型->自定义类型
本质借助构造 隐式类型转换
class MyClass {
public:
// 定义一个构造函数,接收一个 int 类型的参数
MyClass(int value) : data(value) {} // 构造函数初始化 data
void display() const {
std::cout << "Data: " << data << std::endl;
}
private:
int data;
};
int main() {
MyClass obj = 10; // 隐式类型转换:int -> MyClass
obj.display(); // 输出:Data: 10
return 0;
}
2. 自定义类型之间->内置类型
本质要重载一个operator类型 隐式类型转换 如:下面的A
class A
{
public:
operator int()
{
return _a1 + _a2;
}
private:
int _a1 = 1;
int _a2 = 2;
};
int main ()
{
A aa;
int ii1 = aa;
cout << ii1 << endl;
int ii2 = int(aa);
cout << ii2 << endl;
return 0;
}
3. 自定义类型之间->自定义类型
本质借助构造,隐式类型转换 如:initializer_list和容器
#include <iostream>
#include <vector>
class MyContainer {
public:
MyContainer(std::initializer_list<int> init) {
for (int i : init) {
data.push_back(i);
}
}
void display() const {
for (int n : data) {
std::cout << n << " ";
}
std::cout << std::endl;
}
private:
std::vector<int> data;
};
int main() {
MyContainer container = {1, 2, 3};
//当编译器遇到一个初始化列表(例如 {1, 2, 3})并且它被用来初始化容器类型时,会尝试查找一个可以接受 std::initializer_list 参数的构造函数。
//如果找到了,就会隐式调用这个构造函数,将 initializer_list 转换为容器对象
container.display();
return 0;
}
总结: C++ 四种类型转换 掌握其用法就OK 对于关联性类型, 应该去记一下. 本节内容还是很简单, 希望大家喜欢. 谢谢大家!