文章目录

1. C语言中的类型转换
2. 为什么C++需要四种类型转换
3. C++强制类型转换
- static_cast
- reinterpret_cast
- const_cast
- dynamic_cast
4.explicit
5.RTTI
6.考点

1. C语言中的类型转换

在C语言中,如果赋值运算符左右两侧类型不同,或者形参与实参类型不匹配,或者返回值类型与接收返回值类型不一致时,就需要发生类型转化,C语言中总共有两种形式的类型转换：隐式类型转换和显式类型转换

隐式类型转化：编译器在编译阶段自动进行,能转就转,不能转就编译失败, 相近类之间才可以,比如int型转化为double型 (提升和截断本质就是隐式类型转化)
显式类型转化：需要用户自己处理, 不相近类型（意义差别很大的类型) ,比如强制类型转换:int型转化为int*型

需要注意的是,只有相近类型之间才能发生隐式类型转换,比如int和double表示的都是数值,只不过它们表示的范围和精度不同.而指针类型表示的是地址编号,因此整型和指针类型之间不会进行隐式类型转换,如果需要转换则只能进行显式类型转换.比如：

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

缺陷：转换的可视性比较差,所有的转换形式都是以一种相同形式书写,难以跟踪错误的转换

例如:下述这个存在错误的代码:

string& insert(size_t pos, char ch)
{
    assert(pos<=_size);
    if (_size == _capacity)
    {
        reserve(_capacity==0?4:_capacity*2);
    }
    int  end = _size;
    while (end >= pos)
    {
       	_str[end+1] = _str[end];
        --end;
    }
    _str[pos] = ch;//把字符插入到pos位置
    _size++;//数据个数+1
    
    return *this;
}

这里的end和pos进行比较,会发生类型提升, 其实本质就是隐式类型转化

当end减到-1的时候,本来应该要结束的, 但是size_t end = -1,代表的值是42亿多, 导致循环无法结束,就是因为end从int类型提升为size_t类型！

解决方法: end改为size_t类型也是不行的, 必须防止end变为-1的情况可以用指针拷贝

2. 为什么C++需要四种类型转换

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

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

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

3. C++强制类型转换

标准C++为了加强类型转换的可视性,引入了四种命名的强制类型转换操作符：

static_cast、reinterpret_cast、const_cast、dynamic_cast

static_cast

**static_cast用于非多态类型的转换（静态转换） ** 相近类型的转化

编译器隐式执行的任何类型转换都可用static_cast,但它不能用于两个不相关的类型进行转换

int main()
{
	double d = 12.34;
	int a = static_cast<int>(d);
	cout << a << endl;

	int* p = &a;
	// int address = static_cast<int>(p); //error
	return 0;
}

reinterpret_cast

reinterpret_cast操作符通常为操作数的位模式提供较低层次的重新解释, 用于将一种类型转换为另一种不同的类型

reinterpret_cast用于两个不相关类型之间的转换

例子1:

int main()
{
	//例子1:
	int i = 1;
	int* p = nullptr;
	p = reinterpret_cast<int*>(i);
	cout << p << endl;//00000001

	//例子2:
	double d = 12.34;
	int* pd = reinterpret_cast<int*>(&d);
}

例子2:

reinterpret_cast还有一个非常bug的用法,比如在下面的代码中将带参带返回值的函数指针转换成了无参无返回值的函数指针,并且还可以用转换后函数指针调用这个函数.

reinterpret_cast可以让编译器以FUNC的定义方式去看待DoSomething函数

typedef void(*FUNC)();	//FUNC是函数指针,指向的函数返回值是void,没有参数
int DoSomething(int i)
{
	cout << "DoSomething " <<i<<endl;
	return 0;
}

int main()
{
	FUNC f = reinterpret_cast<FUNC>(DoSomething);//以FUNC的定义方式去看待DoSomething函数
	f();	//DoSomething 14028835(随机数)
    return 0;
}

说明一下： 用转换后的函数指针调用该函数时没有传入参数,因此这里打印出参数i的值是一个随机值.

const_cast

const_cast用于删除变量的const属性,转换后就可以对const变量的值进行修改.比如：

int main()
{
    //const修饰的是常变量
    const int a = 10;
    int* p = const_cast<int*>(&a); //去掉了const属性
    *p = 100;
    cout << a << endl;  //10
    cout << *p << endl; //100
    
    cout << &a << endl;//00D9FE08
    cout << p << endl;//00D9FE08
    return 0;
}

为什么a的值是10而不是100呢?我们不是已经修改了a里面的值了嘛?

原因:编译器进行了优化！

因为上面的a的类型const int类型, 被const修饰,编译器认为a的值是不会改变,访问的时候就不用每次都到内存里面取
因此编译器把a的值10保存在寄存器中, 我们修改的是内存中a的值,实际输出的是直接从寄存器中拿的值

如何解决上述这个问题?

加一个volatile修饰告诉编译器不要优化,每次都在内存中取值

int main()
{
    volatile const int a = 10;
    int* p = const_cast<int*>(&a); //去掉了const属性
    *p = 100;
    cout << a << endl;  //100
    cout << *p << endl; //100
    return 0;
}

注意: C++中 const修饰的变量并不一定是存在常量区,如果是局部变量就在栈上,如果是全局变量,就存在常量区

编译的时候不报错.因为看不出a在哪个区域,但是运行的时候会检查, a在常量区,常量区的值不可以修改！

当我们使用const_cast的时候,要非常注意！const属性被去掉以后,会被修改！小心和编译器的优化冲突误判,编译器认为不会修改,但其实可能就被我们人为修改了

总结:

代码中用const_cast删除了变量a的地址的const属性,这时就可以通过这个指针来修改变量a的值.
由于编译器认为const修饰的变量是不会被修改的,因此会将const修饰的变量存放到寄存器当中,当需要读取const变量时就会直接从寄存器中进行读取,而我们修改的实际上是内存中的a的值,因此最终打印出a的值是未修改之前的值.
如果不想让编译器将const变量优化到寄存器当中,可以用volatile关键字对const变量进行修饰,这时当要读取这个const变量时编译器就会从内存中进行读取,即保持了该变量在内存中的可见性.

dynamic_cast

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

向上转型：子类对象指针/引用转换为父类指针/引用 [子类的指针（或引用）→ 父类的指针（或引用）]

向上转型就是所说的切割/切片,是语法天然支持的,不需要进行转换, (不需要转换,赋值兼容规则)

向下转型：父类对象指针/引用转换为子类指针/引用 [父类的指针（或引用）→ 子类的指针（或引用）]

用dynamic_cast转型是安全的, 这种转换相对来说比较安全不会有数据的丢失
当然可以使用强制转换,这种转换时不安全的,会导致数据的丢失,原因是父类的指针或者引用的内存中可能不包含子类的成员的内存

向下转型的安全问题

向下转型分为两种情况：

如果父类的指针（或引用）指向的是一个父类对象,那么将其转换为子类的指针（或引用）是不安全的,因为转换后可能会访问到子类的资源,而这个资源是父类对象所没有的.
如果父类的指针（或引用）指向的是一个子类对象,那么将其转换为子类的指针（或引用）则是安全的.

使用C风格的强制类型转换进行向下转型是不安全的,因为此时无论父类的指针（或引用）指向的是父类对象还是子类对象都会进行转换.而使用dynamic_cast进行向下转型则是安全的,如果父类的指针（或引用）指向的是子类对象那么dynamic_cast会转换成功,但如果父类的指针（或引用）指向的是父类对象那么dynamic_cast会转换失败并返回一个空指针.比如：

class A
{
public:
	virtual void f()
	{}
};
class B : public A
{};
void func(A* pa)
{
	B* pb1 = (B*)pa;               //不安全
	B* pb2 = dynamic_cast<B*>(pa); //安全

	cout << "pb1: " << pb1 << endl;
	cout << "pb2: " << pb2 << endl;
}
int main()
{
	A a;
	B b;
	func(&a);
	func(&b);
	return 0;
}

上述代码中,如果传入func函数的是子类对象的地址,那么在转换后pb1和pb2都会有对应的地址,但如果传入func函数的是父类对象的地址,那么转换后pb1会有对应的地址,而pb2则是一个空指针.

说明一下： dynamic_cast只能用于含有虚函数的类,因为运行时类型检查需要运行时的类型信息,而这个信息是存储在虚函数表中的,只有定义了虚函数的类才有虚函数表.

**注意： **

**1. dynamic_cast只能用于含有虚函数的类 **

2. dynamic_cast会先检查是否能转换成功,能成功则转换,不能则返回0(nullptr)

3.注意:父类的对象赋值给子类的对象是不允许的！哪怕强转但是父类的指针/引用可以向下转型转换为子类指针/引用

例子:

我们想实现这样一个功能:void func(A* pa) A是基类, B是派生类,继承A类

如果pa是指向父类对象,那么不做任何处理
如果pa是指向子类对象,那么请转回子类,并访问子类对象中_b成员

分析:

如果我们直接使用:B* pb1 = static_cast<B*>(pa); 是会直接转化为子类的,不会检查！

class A
{
public:
	virtual void f() {}
	int _a;
};
class B : public A
{
public:
	int _b = 0;
};

//如果pa是指向父类对象,那么不做任何处理
//如果pa是指向子类对象,那么请转回子类,并访问子类对象中_b成员

//父类指针可以接收子类指针 和 父类指针
void func(A* pa)
{

	// dynamic_cast<B*>(pa)--如果pa指向的父类对象,那么则转换不成功,返回nullptr
						  // 如果pa指向的子类对象,那么则转换成功,返回指向对象指针

	B* pb1 = dynamic_cast<B*>(pa); 
	if (pb1 == nullptr)
	{
		cout << "转换失败" << endl;
	}
	else
	{
		cout << "pb1:" << pb1 << endl;
		pb1->_b++;
	}
	
	//dynamic_cast会先检查是否能转换成功,能成功则转换,不能则返回nullptr
	//static_cast会直接转化成功,认为是相近类型,  但是并不会检查
	/*
	B* pb1 = static_cast<B*>(pa);
	B* pb2 = dynamic_cast<B*>(pa);

	cout << "pb1:" << pb1 << endl;
	cout << "pb2:" << pb2 << endl;
	*/
}
int main()
{
	A aa;
	B bb;
	func(&aa);
	func(&bb);

	//父类对象不能赋值给子类对象!!!
	//bb = reinterpret_cast<B>(aa); // reinterpret_cast也不允许
}

原理:

注意:强制类型转换关闭或挂起了正常的类型检查,每次使用强制类型转换前,程序员应该仔细考虑是否还有其他不同的方法达到同一目的,如果非强制类型转换不可,则应限制强制转换值的作用域,以减少发生错误的机会

强烈建议：避免使用强制类型转换

4.explicit

explicit用来修饰构造函数,从而禁止单参数构造函数进行的隐式转换.比如：

class A
{
public :
    explicit A (int a)	//单参构造函数 
    {
        cout<<"A(int a)" <<endl;
    }
    A(const A& a)
    {
        cout<<"A(const A& a)" <<endl;
    }
private :
    int _a ;
};
int main ()
{
    A a1 (1);
    // 隐式转换->1) 先调用单参构造函数生成一个临时对象 A tmp(1)  2) 然后拷贝构造a2  A a2(tmp);   
    A a2 = 1;//由于explicit修饰了单参构造函数,所以不允许隐式类型转化！ 报错
	return 0;
}

A a2 = 1 等价于: A tmp(1); //先构造 A a2(tmp); //再拷贝构造

所以在早期的编译器中,当编译器遇到A a2 = 1这句代码时,会先构造一个临时对象,再用这个临时对象拷贝构造a2.但是现在的编译器已经做了优化,当遇到A a2 = 1这句代码时,会直接按照A a2(1)的方式进行处理,这叫做隐式类型转换.

但对于单参数的自定义类型来说,A a2 = 1这种代码的可读性不是很好,因此可以用explicit修饰单参数的构造函数,从而禁止单参数构造函数的隐式转换.

5.RTTI

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

C++通过以下方式来支持RTTI：

typeid操作符 typeid用于返回指针或引用所指对象的实际类型

class A
{
	virtual void f() {}
public:
};
class B : public A
{
public:
	int _b = 0;
};
int main()
{
	B b;
	A& a = b;
	cout << typeid(a).name() << endl;//class B
	return 0;
}

对非引用类型,typeid是在编译时期识别的,只有引用类型才会在运行时识别

2.dynamic_cast运算符

3.decltype：在运行时推演出一个表达式或函数返回值的类型.

6.考点

1.C++中4种强制类型转化类型是什么? 分别作用是什么?

C++中四种类型转换分别为const_cast、static_cast、dynamic_cast、reinterpret_cast,四种转换功能分别如下：

const_cast: 将const变量转为非const
static_cast: 可以用于各种隐式转换,比如非const转const,static_cast可以用于类向上转换,但向下转换能成功但是不安全
dynamic_cast : 只能用于含有虚函数的类转换,用于类向上和向下转换

向上转换：指子类向基类转换
向下转换：指基类向子类转换
这两种转换,子类包含父类,当父类转换成子类时可能出现非法内存访问的问题dynamic_cast通过判断变量运行时类型和要转换的类型是否相同来判断是否能够进行向下转换
dynamic_cast可以做类之间上下转换,转换的时候会进行类型检查,类型相等成功转换,类型不等转换失败
运用RTTI技术,RTTI是”Runtime Type Information”的缩写,意思是运行时类型信息,它提供了运行时确定对象类型的方法,在c++层面主要体现在dynamic_cast和typeid