AmosTian

0%

4.数据类型转换

发表于 更新于 分类于 > >
本文字数 1.1k字 | 阅读时长 ≈ 2 分钟

graph LR;
A[数据类型转换]---->B[隐式数据类型转换]
A-->C["显式数据类型转换"]
C---->D["static_cast：内置数据类型向下转换"]
C---->E["const_cast:去除常指针常引用"]
C---->F["reinterpret_cast:重新解释类型，不改变bit"]
C---->G["dynamic_cast:基类与派生类动态绑定的转换"]

4.1 隐式数据类型转换

  • 逻辑运算操作结果必须为 bool

    非0转换为 true ，0转换为 false

  • 位运算操作数必须是整数

    字节数少的转换为字节数多的类型

    赋值运算一律将右值转换为左值

4.2 显式数据类型转换

C语言的数据类型转换很简单

TYPE b = (TYPE) a;

C++的类型转换提供更好的控制强制转换过程，允许控制各种不同种类的强制类型转换

4.2.1 static_cast

静态转换：可以实现内置基本数据类型之间的转换

TYPE b = static_cast<TYPE>(a);

  • 只能在有联系的类型之间相互转换
  • 不一定包含虚函数
  • 在编译时进行转换

  1. 用于基类和子类之间转换

    子类指针转换成父类指针是安全的

    父类指针转换成子类指针是不安全的

  2. 基本数据类型转换

  3. 把空指针转换成目标类型的空指针

  4. 把任何类型的表达式转换成void类型

1
2
3
4
5
int a = 6;
double b = static_cast<int>(a);
int *pn = &a;
double *d = static_cast<double *>(pn);
void *p = static_cast<void *>(pn);

4.2.2 const_cast

常量转换：用于取出常指针或常引用的const属性（把const指针转换为非const指针）

  • 不能转换不同类型的白能量
  • 只能用于指针或常引用
  • 在编译时转换
1
2
3
4
const int a= 0;
int b = const_cast<int>(a);//不对，不可修改常量的const
const int *pi = &a;
int * pii = const_cast<int *>pi;//去除指针中的常量性，也可以添加指针的常量性;
1
2
3
4
5
6
7
struct S{
	int i;
};
const S ra;
//ra.i = 10; //编译报错，不能直接修改const类型
S &rb = const_cast<S &>(ra);
rb.i = 10；//编译通过

4.2.3 reinterpret_cast

重新解释转换：不同类型的指针类型转换

  • 操作结果只是简单的从一个指针到别的指针的值拷贝

    指针，引用，算法类型，函数指针或成员指针

  • 编译时

  • 用于 多态类 ，函数指针类型之间的转换

1
2
3
4
5
/*
reinterpret_cast把一个指针转换成一个整数，也可以把一个整数转换成一个指针（先把一个指针转换成一个整数，在把该整数转换成原类型的指针，还可以得到原先的指针值）。
*/
int *ip;
char *pc = reinterpret_cast<char*>(ip);

在比特级别进行转换。将一个指针转换成一个整数，也可以把一个整数转换成一个指针，只能将32bit实例转换成指针

1
2
3
4
5
6
7
8
9
int doSomething(){
    return 0;
}

typedef void (*FuncPtr)();//FuncPtr一个函数指针，没有参数，返回值类型为void 
FuncPtr funcPtrArray[10];

funcPtrArray[0] = &doSomething;//编译错误：类型不匹配
funcPtrArray[0] = reinterpret_cast<FuncPtr>(&doSomething);//不同函数指针类型之间的转换

4.2.4 dynamic_cast

动态转换：转换成功，则返回类的指针或引用，失败则返回null

  • 不能用于内置基本类型的强制转换

  • 运行时进行类型安全检查

  1. 安全的基类和子类转换

    上行转换时，动态转换和静态转换效果相同

    下行转换时，动态转换具有类型检查功能，更安全

  2. 使用动态转换，基类(抽象类)中一定要有虚函数

  3. 相同基类不同子类之间的交叉转换，但结果是 NULL

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
class BaseClass{
	public:
    int num;
    virtual void fun(){};
};

class DerivedClass:public BaseClass{
	public:
    char *name[10];
    void bar(){};
};

//上行转换
BaseClass *pb = new DerivedClass();
DerivedClass *pb1 = static_cast<DerivedClass *>(pb);//子类->父类，静态类型转换，正确但不推荐
DerivedClass *pd2 = dynamic_cast<DerivedClass *>(pb); //子类->父类，动态类型转换，正确

/*下行转换*/
BaseClass* pb2 =new BaseClass();
DerivedClass *pd21 = static_cast<DerivedClass *>(pb2); //父类->子类，静态类型转换，危险！访问子类name成员越界
DerivedClass *pd22 = dynamic_cast<DerivedClass *>(pb2); //父类->子类，动态类型转换，安全的。转换结果是NULL
-------------本文结束-------------