适合具备 C 语言基础的 C++ 教程（八）
适合具备 C 语言基础的 C++ 教程（八）
前言
在前一则教程中，我们阐述了多态的相关概念，其中就包括实现多态所必须的虚函数，以及使用多态这个性质时一些限制的内容，本节教程将着重讲解 C++中的类型转换问题，其中就包括：dynamic_cast、static_cast、reinterpret_cast以及const_cast。
C语言的类型转换
隐式类型转换
我们在使用C语言进行编程的时候，时常会涉及到类型转换的问题，我们首先就隐式的类型转换进行阐述，话不多说，我们来看一段代码：
#include <stdio.h>
int main(int argc, char **argv)
{
double d = 100.1;
int i = d; // double to int
char *str = "100ask.taobao.com";
int *p = str; // char * to int *
printf("i = %d, str = 0x%x, p = 0x%x\n", i, str, p);
return 0;
}
单就上述的代码来看，就涉及到我们所说的隐式转换，int i = d这句代码就是 int到double的隐式转换，而int *p = str所涉及的就是char* 到 int *的转换，上述代码编译的结果如下所示：
image-20210220203259062
看到上述编译信息，我们看到三个警告信息，第一个警告信息说的是 int *p =str;这句代码，int *p这是一个变量，要去操作str这个字符串，这个字符串是一个常量，这个警告旨在提醒程序员要注意这个地方；第二个警告和第三个警告的意思都是一样的，因为程序使用的是 %x进行输出，那么这个输出的变量就需要是 unsigned int的，但是这里输出的两个变量信息，一个str，一个p，都不是 unsigned int的，所以也就造成了警告。
强制转换
那么要如何消除这些警告呢，这个时候，就需要使用显示转换，在 C语言中也被称之为是强制转换，代码如下所示：
#include <stdio.h>
int main(int argc, char **argv)
{
double d = 100.1;
int i = d; // double to int
char *str = "100ask.taobao.com";
int *p = (int *)str; // char * to int * 这里进行了更改
printf("i = %d, str = 0x%x, p = 0x%x\n", i, (unsigned int)str, (unsigned int)p); // 这里进行了更改
return 0;
}
这个时候，在编译代码的时候，编译信息如下所示：
image-20210220204015157
这个时候，我们可以看到刚刚三个警告信息已经没有了，但是又出来了两个警告，这个是什么意思呢？这是因为当前使用的系统是64位的，那么 char *和int *是8个字节，但是unsigned int来说，只有4个字节，所以也就造成了上述的警告，但是这个警告与本节所讲的类型转换无关，其涉及到所使用的编译平台的区别。
C++ 的类型转换
本节的核心内容还是讲解 C++的，上述中的 C语言部分是为了引出C++的强制转换，在上述中，我们提及了 C语言的隐式转换和强制转换，实际上在 C++中也有与之对应的内容，在 C++中跟强制转换效果一样的便是reinterpret_cast。
reinterpret_cast
reinterpret_cast的效果就相当于是 C语言中的强制类型转换，使用方法如下面代码所示：
#include <stdio.h>
int main(int argc, char **argv)
{
double d = 100.1;
int i = d; // double to int
char *str = "100ask.taobao.com";
int *p = reinterpret_cast<int *>(str); // char * to int *
printf("i = %d, str = 0x%x, p = 0x%x\n", i, reinterpret_cast<unsigned int>(str), reinterpret_cast<unsigned int>(p));
return 0;
}
将上述代码进行编译，编译结果如下所示：
image-20210220205252531
编译之后，如上图所示，出现了两个错误，这个错误也是刚刚在 C语言编译时警告所提及的，就是因为当前的操作系统是 64位的，而char *和int *是8个字节，但是unsigned int是4个字节，将8个字节的变量转换为4个字节会导致精度降低，我们按照错误提示在编译选项中又加入了一项，便消除了错误，编译命令以及编译结果如下图所示：
image-20210220205602226
const_cast
在上述编译结果中，我们可以看到第一个警告信息，说的是char* str = "100ask.taobao.com"这条代码，意思是"100ask.taobao.com"这个字符串是 const的，但是 str并不是 const的，所以我们在 char *str前加上 const，这样做会存在什么问题呢，更改后的代码如下所示：
#include <stdio.h>
int main(int argc, char **argv)
{
double d = 100.1;
int i = d; // double to int
const char *str = "100ask.taobao.com";
int *p = reinterpret_cast<int *>(str2);// char * to int *
printf("i = %d, str = 0x%x, p = 0x%x\n", i, reinterpret_cast<unsigned int>(str), reinterpret_cast<unsigned int>(p));
return 0;
}
代码编译的结果如下所示：
image-20210220210313863
出现了一个错误，错误的意思是不能将 const char*转换为int *的，更改的思路也很清晰，不能将const的转换为非const的，那么就将 const去掉就好了，这个时候，就需要使用到 const_cast了，具体代码如下所示：
#include <stdio.h>
int main(int argc, char **argv)
{
double d = 100.1;
int i = d; // double to int
const char *str = "100ask.taobao.com";
char *str2 = const_cast<char *>(str); //更改过的
int *p = reinterpret_cast<int *>(str2); // char * to int *
printf("i = %d, str = 0x%x, p = 0x%x\n", i, reinterpret_cast<unsigned int>(str), reinterpret_cast<unsigned int>(p));
return 0;
}
继续编译代码，代码编译结果如下所示：
image-20210220210745834
这个时候，代码就是正确的了。
dynamic_cast
动态类型转换，要说清楚这个概念，需要将之前的一个例子拿出来叙述，人类，中国人，英国人这个例子，先回顾下这几个类的代码，代码如下所示：
class Human
{
private:
int a;
public:
virtual void eating(void) { cout<<"use hand to eat"<<endl; }
virtual ~Human() { cout<<"~Human()"<<endl; }
virtual Human* test(void) {cout<<"Human's test"<<endl; return this; }
};
class Englishman : public Human
{
public:
void eating(void) { cout<<"use knife to eat"<<endl; }
virtual ~Englishman() { cout<<"~Englishman()"<<endl; }
virtual Englishman* test(void) {cout<<"Englishman's test"<<endl; return this; }
};
class Chinese : public Human
{
public:
void eating(void) { cout<<"use chopsticks to eat"<<endl; }
virtual ~Chinese() { cout<<"~Chinese()"<<endl; }
virtual Chinese* test(void) {cout<<"Chinese's test"<<endl; return this; }
};
上述是这几个类的代码实现，在之前的代码中，我们还编写了一个测试函数，代码如下所示：
void test_eating(Human& h)
{
h.eating();
}
然后是主函数的代码：
int main(int argc, char **argv)
{
Human h;
Englishman e;
Chinese c;
test_eating(h);
test_eating(e);
test_eating(c);
return 0;
}
上述所体现的是多态的特性，但是现在我想新增加一个功能，也就是能够区分出来当前是英国人还是中国人，按照之前编写 C语言的习惯，我们自然会想到增加一个type，然后不同的国籍，给type赋不同的值，然后根据数值来判断当前是中国人还是英国人，这是一个比较拙劣的方法，在 C++中，我们使用 dynamic_cast来实现这个功能。
首先给出代码实现：
void test_eating(Human& h)
{
Englishman *pe;
Chinese *pc;
h.eating();
/* 想分辨这个"人"是英国人还是中国人? */
if (pe = dynamic_cast<Englishman *>(&h))
cout<<"This human is Englishman"<<endl;
if (pc = dynamic_cast<Chinese *>(&h))
cout<<"This human is Chinese"<<endl;
}
在主函数不发生改变的情况下，代码运行结果如下所示：
image-20210220211828607
可以看到结果分辨出来了当前人属于哪个国家，这种写法为什么可以实现呢，这就要提到之前在叙述多态的时候索尼提及的虚函数，我们继续来看之前的那张图，相比于之前那张图，这张图增加了类的信息这一属性，图示如下：
image-20210220212322874
也就是说类中存在一个指针，这个指针不仅指向了虚函数表，而且指向了类信息,通过指针指向的类信息，我们可以知道当前这个对象是属于哪个类的，而且也能够知道当前这个类的继承信息，换言之，在使用 dynamic_cast进行类型转换的时候，类必须具有虚函数。
刚刚的两个动态类型转换均是由Human转换为 Englishman和chinese，属于是下行转换，也就是基类对象转换为派生类对象，那么对于将派生类对象转换为基类对象，也就是上行转换，又是如何实现的呢？首先，我们先定义一个Guangximan，代码如下所示：
class Guangximan : public Chinese
{
public:
void eating(void) { cout<<"use chopsticks to eat, I come from guangxi"<<endl; }
};
在 test_eating函数里增加如下代码：
void test_eating(Human& h)
{
Englishman *pe;
Chinese *pc;
Guangximan *pg;
h.eating();
/* 想分辨这个"人"是英国人还是中国人? */
if (pe = dynamic_cast<Englishman *>(&h))
cout<<"This human is Englishman"<<endl;
if (pc = dynamic_cast<Chinese *>(&h))
cout<<"This human is Chinese"<<endl;
if (pg = dynamic_cast<Guangximan *>(&h))
cout<<"This human is Guangximan"<<endl;
}
主函数代码如下所示：
int main(int argc, char **argv)
{
Guangximan g;
test_eating(g);
return 0;
}
代码执行结果如下所示：
image-20210220213511794
可见上行转化也是可行的，而且通过上述的打印信息，我们可以知道，类中指针指向的类信息不仅包含其所述的类而且包含其继承关系这个信息，不然也就不会打印出This human is chinese了。
上述的是将指针进行动态转换的一个例子，那么如果是使用引用呢，如何进行转换，代码如下所示：
void test_eating(Human& h)
{
Englishman& pe = dynamic_cast<Englishman&>(h);
Chinese& pc = dynamic_cast<Chinese&>(h);
Guangximan& pg = dynamic_cast<Guangximan&>(h);
h.eating();
}
主函数代码如下所示：
int main(int argc,char **argv)
{
Guangximan g;
test_eating(g);
return 0;
}
执行上述代码，会出现如下错误：
image-20210220220252345
这是因为将Guangximan转换为了Englishman,这两个类之间没有直接联系，所以也就造成了错误，这里要指出的一点是：指针转换时，如果转换不成功，进行判断就可以避免系统崩溃，但是引用不行，如果引用转换不成功，引用不能够指向一个不存在的实体，那么就必然导致系统崩溃。
最后，关于动态类型转换收尾一下，动态类型转换，之所以被称之为是动态的，也是因为其是再程序运行过程中确定的转换类型，就如上面的test_eating()函数来说，只有运行到这里，才知道要转换的类型是 Human。
static_cast
静态类型转换跟动态类型转换则存在不同，它的转换则是由编译的时候就由编译器确定好了转换的类型。为了验证静态类型转换，我们来看如下所示的代码：
int main(int argc,char** argv)
{
Human h;
Englishman *pe;
pe = static_cast<Englishman *>(&h);
return 0;
}
上面是将 Human转换为了 Englishman，属于是下行转化，在编译的时候，没有报错和警告，虽然存在隐患，但是在使用 static_cast的时候没有检测出来。
紧接着，我们来看如下的代码：
int main(int argc,char** argv)
{
Guangximan g;
Englishman *pe2 = static_cast<Englishman *>(&g);
return 0;
}
可以看到当把Guangximan转换为与之没有关系的Englishman的时候，编译代码，结果如下所示：
image-20210220221922297
这也说明了 static_cast对这种没有直接关系的类提供了安全保障，我们紧接着来看静态类型转换的上行转换，代码如下所示：
int main(int argc,char** argv)
{
Guangximan g;
Chinese *pc = static_cast<Chinese *>(&g);
return 0;
}
进行这种上行转换时，编译没有问题，说明对于 static_cast是支持的。
最后，对于 static_cast进行一下总结：
- 用于类层次结构中基类和子类之间指针或引用的转换。
- 进行上行转换（把子类的指针或引用转换成基类表示）是安全的；
- 进行下行转换（把基类指针或引用转换成子类指针或引用）时，由于没有动态类型检查，所以是不安全的。
- 用于基本数据类型之间的转换，如把int转换成char，把int转换成enum：这种转换的安全性也要开发人员来保证。
- 把void指针转换成目标类型的指针(不安全!!)
- 把任何类型的表达式转换成void类型。
注意：static_cast不能转换掉expression的const、volitale、或者__unaligned属性。
总结
上述内容就是本次分享的关于 C++类型转换的内容，本节所涉及到的代码可以通过百度云链接的方式获取：
链接：https://pan.baidu.com/s/1VJAKnBpO4_98YzzvqHd_JQ 提取码：ricg