目录
一 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 对于关联性类型, 应该去记一下. 本节内容还是很简单, 希望大家喜欢. 谢谢大家!
扫一扫
2211
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
