类型转换

1.1 强制类型转换

语法：C中在变量名或具体数值前使用()表示进行强制类型转换；

(Type) Expression

Type(Expression)

注:

1. 当目标类型能够容纳目标值时，结果不变；
2. 当目标类型不能容纳目标值时，结果产生截断；
3. 不是所有的强制类型转换都能成功，例如自定义类型与基本类型进行转换；编译器将报错

#include <stdio.h>

struct TS
{
       int i;
       int j;
};

struct TS ts;

int main()
{
       short s = 0x1122;
       char  c = (char)s;
       int   i = (int )s;
       int   j = (int)3.14;
       unsigned int p = (unsigned int)&ts;  //32位正常 64位截断
       long  l = (long)ts;
       ts      = (struct TS)l;

       printf("s = %x
", s);
       printf("c = %x
", c);
       printf("i = %x
", i);
       printf("j = %x
", j);
       printf("p = %x
", p);
       printf("&ts = %p
", &ts);

       return 0;
}

1.2 隐式类型转换

编译器主动进行的类型转换即隐式类型转换；

称某类型在内存中所占用的字节数少为类型。则相应的，低类型向高类型的隐式类型转换时安全的，相反地，则类型转换将产生不正确的结果；

发生时机：

1. 算术运算式：低类型转换为高类型
2. 赋值表达式，表达式的值转换为左边变量类型的值
3. 函数调用，实参转换为形参的类型；
4. 函数返回值，return表达式转换为返回值类型

#include <stdio.h>

int main()
{
       char         c = 'a';
       int          i = c;
       unsigned int j = 0x11223344;
       short        s = j;

       printf("c = %c
", c);
       printf("i = %d
", i);
       printf("j = %x
", j);
       printf("s = %x
", s);
       printf("sizeof(c + s) = %d
", sizeof(c + s));  //char → int shor → int sizeof(int+int) = int;

       return 0;
}

1.3安全的隐式类型转换

char/short  →  int →  unsigned int  →  long  →  unsigned long  →  float  →  double

char → short

1.4 C++中的类型转换

如1.1中所示，C语言中强制类型转换在任意类型之间都可以进行转换，编译器很难判断正确性，C++中的强制类型转换分为4种不同类型：

1.4.1 static_cast

用于基本类型间转换

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

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

#include<stdio.h>

int main()
{
       int i = 0x12345;
       char c = 'c';
       int* pi = &i;
       char* pc = &c;

       c = static_cast<char>(i);
       pc= static_cast<char*>(pi); //error

       return 0;
}

1.4.2 const_cast

用于去除变量的只读属性

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

#include<stdio.h>

int main()
{
       const int& j = 1;
       int& k = const_cast<int&>(j);   //k = 1

       const int x = 2;                //x = 2常量

       int& y = const_cast<int&>(x);   //y = 2
       int z = const_cast<int>(x);     //error

       k = 5;

       printf("k = %d
", k);          //k=5
       printf("j = %d
", j);          //j=5

       y = 8;

       printf("x = %d
", x);          //x = 2
       printf("y = %d
", y);          //y = 8
       printf("&x = %p
", &x);
       printf("&y = %p
", &y);

       return 0;  
}

1.4.3 reinterpret_cast

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

用于整数和指针类型间的强制转换(嵌入式代码)

#include<stdio.h>

int main()
{
       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); //error

       return 0;
}

1.4.4 dynamic_cast

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

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

具有类型检查的功能(若转换不成功反馈NULL)

需要虚函数的支持

#include<stdio.h>

int main()

{

       int i = 0;
       int pi = &i;

       char* pc = dynamic_cast<char*>(pi); //error

       return 0;
}