新型类型的转换

一、C语言强制类型转换

    1.C方式强制类型转换存在的问题

     ---过于粗暴

       .任意类型直接都可以进行转换，编译器很难判断其正确性

     ---难于定位

       .在源码中无法快速定位所有使用强制类型转换语句

可以编译通过，运行后发生段错误：

#include <stdio.h>

typedef void(PF)(int);

struct Point
{
    int x;
    int y;
};

int main()
{
    int v = 0x12345;
    PF* pf = (PF*)v;
    char c = char(v);
    Point* p = (Point*)v;
    
    pf(5);
    
    printf("p->x = %d\n", p->x);
    printf("p->y = %d\n", p->y);

    return 0;
}

二、C++中的新式类型转换

 C++中将强制类型转换分为4种不同类型

                           

staitc_cast	const_cast
dynamic_cast	reinterpret_cast

                    用法：        xxx_cast <type> (Expression)

 

1.static_cast强制类型转换

        --基于基本类型间的转换

        --不能用于基本类型指针间的转换

        --用于有继承关系类对象之间的转换和类指针之间的转换

 2.const_cast强制类型转换

          --用于去除变量的只读属性

          --强制转换的目标类型必须是指针或引用

3.reinterpret_cast强制类型转换

     -- 用于指针类型间的强制类型转换

     -- 用于整数和指针类型间的强制转换(将整数强制转换成一个指针)

 4.dynamic_cast强制类型转换

        --用于有继承关系的类指针间的转换

       --用于有交叉关系的类指针间的转换

       --具有类型检查的功能

       --需要虚函数支持

#include<stdio.h>

void static_cast_demo()
{
    int i=0x12345;
    char c = 'c';
    int* pi = &i;
    char* pc=&c;	
	
	 c=static_cast<char>(i); //强制类型转换
	//pc=static_cast<char*>(pi)  //错误，static_cast用于基本类型间转换	
}

void const_cast_demo()
{
	const int& j=1;  //j为只读变量
	
	int& k=const_cast<int&>(j); //去掉j的只读属性
	
	const int x =2;          //x是常量并且进入符号表
    int& y=const_cast<int&>(x);  //y是编译器为x分配内存空间的别名，x在符号表中
	
   //int z = const_cast<int>(x);    //错误，const_cast只能用于指针与引用中
	
	k =5;
	printf("k = %d\n",k);
	printf("j = %d\n",j);
	
	y =9 ;
	printf("x = %d\n",x);
	printf("y = %d\n",y);
    printf("&x = %p\n",&x);
    printf("&y =%p\n",&y);	
}
void reinterpret_cast_demo()
{
	int i=0;
	char c ='c';
	int* pi= &i;
	char* pc=&c;
	
	pc=reinterpret_cast<char*>(pi);
	pi=reinterpret_cast<int*>(pc);
	pi=reinterpret_cast<int*>(i);
	//c=reinterpret_cast<char>(i);  //只能用于指针之间转换和整数与指针之间
}
void dynamic_cast_demo()
{
	int i=0;
	int* pi=&i;
	//char* pc=dynamic_cast<char*>(pi);//只能用于类指针之间，还需要虚函数的支持
}
int main()
{
	static_cast_demo();
	const_cast_demo();
	reinterpret_cast_demo();
	dynamic_cast_demo();
	
    return 0;
}

三、小结

  1.C方式的强制类型转换

      过于粗暴

        潜在的问题不易被发现

       不易于在代码中定位

 2.新式类型转换以C++关键字的方式出现

      编译器能够帮助检查潜在的问题

     非常方便的在代码中定位

     支持动态类型识别(dynamic_cast)