C++ 类型转换的实现

---

Part.I 各种类型转换

下面针对几种常用的类型说明C++各种类型之间相互转换的实现。

Chap.0 总结

关于 C++ 中字符相关的类型有：

类型	说明
char	用单引号''引起来的一个字符，可以重新赋值
char []	指针常量，可以理解为char * (const xx)；其值（指向）不能更改；但是其指向目标（在内存中的区域）的内容可变。最后有一个 '\0'结束符作为字符串的结束标志。
char *	指针变量，其值（指向）可以改变，可以通过它来更改指向区域的内容
const char *	指针变量，其值（指向）可以改变，但是只能指向常量，不能通过它来更改指向区域的内容，通过别的或许可以。
char const *	等价于const char *
char * const	指针常量，其值（指向）不能更改；但是可以通过它来更改指向区域的内容
string	C++ 新增的一个类，用双引号""引起来的字符串，对其操作十分灵活。要引用头文件#include <string>
CString	常用于MFC编程中，是属于MFC的类

---

其转换如下：

---

字符串与其他简单类型的转换

Chap.I String 与其他类型之间的

数值型比如 int, float, double 转换为 string 可以使用函数std::to_string()；string 转换为数值型可以使用下面的函数。

使用方法也比较简单，直接int a=stoi(str);即可！

另外，string 转换为 char *类型可以使用strcpy(tmp,a.c_str());； char *类型转换为string 直接赋值即可。另外，需要注意的是str[i]切片操作得到的是char，str.substr(beg,len)操作得到的还是string。

Chap.II char* 与其他类型之间

char *与其他类型之间可以通过string为桥梁，然后再通过string的函数来进行转换，下面也有一些比较巧妙的操作：

转换方法	作用
2+'0'	int 转 char，隐式类型转换
a-'0'	char 转 int，隐式类型转换

Chap.III 复杂类型/容器之间的转换

Vector 与数组之间的转换，比如一个vector<int>和一个int a[v.size]之间的转换：

// vector<int> → int []
vector<int> v(10,1);				// 已知
int a[v.size()];					// 首先给目标 int[] 分配内存
memcpy(a, &v[0], v.size() * sizeof(v[0]));
------------------------------
// vector<int> → int []
vector<int> v(a, a + sizeof(a));	//构造时就可
------------------------------
vector<int> v(N);					//另一种方式，N为数组长度
memcpy(&V[0], a, sizeof(a));

---

Vector 与 Set 之间的转换

set<int> st(vec.begin(), vec.end());	// vector → set
------------------------------
vec.assign(st.begin(), st.end());		// set → vector

---

Part.II 底层原理

C++类型转换主要分为两种：隐式类型转换、显式类型转换（强制类型转换）。隐式类型转换主要是通过operator（类型转换函数）来实现的；强制类型转换主要用到四个关键字，下面博客内容就按隐式→显式的四个关键字 来展开。

Chap.I 隐式类型转换

基本数据类型之间进行隐式转换的几种情况：

1、算术转换(Arithmetic conversion) : 在混合类型的 算术表达式 中, 位数最宽的数据类型成为目标转换类型。例如：

int i=3;
double j = 3.1;
i+j;//i会被转换成double类型，然后才做加法运算。

2、一种类型表达式赋值给另一种类型的对象：目标类型是被赋值对象的类型。例如：

int inum = -1;
unsigned int uinum = 1;
double dnum = 2.3;
uinum = inum; //4294967295
inum = dnum;  //2

这种情况的转换，窄类型转换为宽类型一般没有问题，宽类型转换为窄类型一般会截断转换，有符号类型转换为无符号类型会出现我们不想出现的情况。

3、将一个表达式作为实参传递给函数调用，此时形参和实参类型不一致：目标转换类型为形参的类型。例如：

extern double sqrt( double );
cout << " The square root of 2 is  " << sqrt(2) << endl;
// 2被提升为double类型：2.0

4、从一个函数返回一个表达式，表达式类型与返回类型不一致：目标转换类型为函数的返回类型。例如：

double difference(int ival1, int ival2)
{
	return ival1 - ival2;
	// 返回值被提升为double类型
}

---

使用子类对象代替父类对象是可以的，也是因为隐式类型转换：

class A{};
class B: public A
{};//B是子类
void Fun(A& a);
B b;
Fun(b);//使用子类对象代替父类对象是可以的，也是因为隐式类型转换。

如果想将当前类类型转换为其他类型的时候，该怎么做呢？C++ 提供了类型转换函数（Type conversion function）来解决这个问题，它只能以成员函数的形式出现，也就是只能出现在类中。类型转换函数的语法格式为：

operator type(){
    //TODO:
    return data;
}

operator 是 C++ 关键字，type 是要转换的目标类型，data 是要返回的 type 类型的数据。

因为要转换的目标类型是 type，所以返回值 data 也必须是 type 类型。既然已经知道了要返回 type 类型的数据，所以没有必要再像普通函数一样明确地给出返回值类型。这样做导致的结果是：类型转换函数看起来没有返回值类型，其实是隐式地指明了返回值类型。

类型转换函数也没有参数，因为要将当前类的对象转换为其它类型，所以参数不言而喻。实际上编译器会把当前对象的地址赋值给 this 指针，这样在函数体内就可以操作当前对象了。

类型转换函数可以看成式转换构造函数的逆，因为转换构造函数能够将其它类型转换为当前类类型，而类型转换函数可以将当前类类型转换为其他类类型。下面看个例子：

//复数类
class Complex{
public:
    Complex(): m_real(0.0), m_imag(0.0){ }
    Complex(double real, double imag): m_real(real), m_imag(imag){ }
public:
    friend ostream & operator<<(ostream &out, Complex &c);
    friend Complex operator+(const Complex &c1, const Complex &c2);
    operator double() const { return m_real; }  //类型转换函数
private:
    double m_real;  //实部
    double m_imag;  //虚部
};

里面operator那一行，就是类型转换函数，它可以将复数类型转换为double类型，有了它，下面的代码就可以成功运行了：

Complex c1(24.6, 100);
double f = c1;  //相当于 double f = Complex::operator double(&c1);

Chap.II 显式类型转换

笔者认为C++是对C补充和更新，首先看C的强制转换：

(type-id)expression//转换格式1
type-id(expression)//转换格式2

c语言强制类型转换主要用于 基础的数据类型间的转换，c++除了能使用c语言的强制类型转换外，还新增了四种强制类型转换：static_cast、dynamic_cast、const_cast、reinterpret_cast，主要运用于继承关系类间的强制转化：

static_cast<new_type>      (expression)
dynamic_cast<new_type>     (expression) 
const_cast<new_type>       (expression) 
reinterpret_cast<new_type> (expression)

new_type为目标数据类型，expression为原始数据类型变量或者表达式。对其简单如下表所示：

关键字	说明
static_cast	用于良性转换，一般不会导致意外发生，风险很低。
const_cast	用于 const 与非 const、volatile 与非 volatile 之间的转换。
reinterpret_cast	高度危险的转换，这种转换仅仅是对二进制位的重新解释，不会借助已有的转换规则对数据进行调整，但是可以实现最灵活的 C++ 类型转换。
dynamic_cast	借助 RTTI，用于类型安全的向下转型（Downcasting）。
有的书中，将c语言强制类型转换称为旧式转型，c++强制类型转换称为新式转型。

Sec.I static_cast

static_cast 是“静态转换”的意思，也就是在编译期间转换，转换失败的话会抛出一个编译错误。

static_cast 只能用于良性转换，这样的转换风险较低，一般不会发生什么意外，例如：

• 原有的自动类型转换，例如 short 转 int、int 转 double、const 转非 const、向上转型等；
• void 指针和具体类型指针之间的转换，例如void *转int *、char *转void *等；
• 有转换构造函数或者类型转换函数的类与其它类型之间的转换，例如 double 转 Complex（调用转换构造函数）、Complex 转 double（调用类型转换函数）。

需要注意的是，static_cast 不能用于无关类型之间的转换，因为这些转换都是有风险的，例如：

• 两个具体类型指针之间的转换，例如int *转double *、Student *转int *等。不同类型的数据存储格式不一样，长度也不一样，用 A 类型的指针指向 B 类型的数据后，会按照 A 类型的方式来处理数据：如果是读取操作，可能会得到一堆没有意义的值；如果是写入操作，可能会使 B 类型的数据遭到破坏，当再次以 B 类型的方式读取数据时会得到一堆没有意义的值。
• int 和指针之间的转换。将一个具体的地址赋值给指针变量是非常危险的，因为该地址上的内存可能没有分配，也可能没有读写权限，恰好是可用内存反而是小概率事件。
• static_cast 也不能用来去掉表达式的 const 修饰和 volatile 修饰。换句话说，不能将 const/volatile 类型转换为非 const/volatile 类型。

下面是一些用法示例：

//下面是正确的用法
int m = 100;
Complex c(12.5, 23.8);
long n = static_cast<long>(m);  //宽转换，没有信息丢失
char ch = static_cast<char>(m);  //窄转换，可能会丢失信息
int *p1 = static_cast<int*>( malloc(10 * sizeof(int)) );  //将void指针转换为具体类型指针
void *p2 = static_cast<void*>(p1);  //将具体类型指针，转换为void指针
double real= static_cast<double>(c);  //调用类型转换函数

//下面的用法是错误的
float *p3 = static_cast<float*>(p1);  //不能在两个具体类型的指针之间进行转换
p3 = static_cast<float*>(0X2DF9);  //不能将整数转换为指针类型

Sec.II const_cast

const_cast 比较好理解，它用来去掉表达式的 const 修饰或 volatile 修饰。换句话说，const_cast 就是用来将 const/volatile 类型转换为非 const/volatile 类型。看下面的例子：

const int n = 100;
int *p = const_cast<int*>(&n);
*p = 234;
cout<<"n = "<<n<<endl;   //  n = 100
cout<<"*p = "<<*p<<endl; //  *p = 234

&n用来获取 n 的地址，它的类型为const int *，必须使用 const_cast 转换为int *类型后才能赋值给 p。由于 p 指向了 n，并且 n 占用的是栈内存，有写入权限，所以可以通过 p 修改 n 的值。也就是说：p 和&n指向的是相同的地址。

有读者可能会问，为什么通过 n 和 *p 输出的值不一样呢？这是因为 C++ 对常量的处理更像是编译时期的#define，是一个值替换的过程，代码中所有使用 n 的地方在编译期间就被替换成了 100。换句话说，cout<<"n = "<<n<<endl;这行代码被修改成了cout<<"n = "<<100<<endl;

这样以来，即使程序在运行期间修改 n 的值，也不会影响 cout 语句了。使用 const_cast 进行强制类型转换可以突破 C/C++ 的常数限制，修改常数的值，因此有一定的危险性；但是程序员如果这样做的话，基本上会意识到这个问题，因此也还有一定的安全性。

Sec.III reinterpret_cast

reinterpret 是“重新解释”的意思，顾名思义，reinterpret_cast 这种转换仅仅是对二进制位的重新解释，不会借助已有的转换规则对数据进行调整，非常简单粗暴，所以风险很高。

reinterpret_cast 可以认为是 static_cast 的一种补充，一些 static_cast 不能完成的转换，就可以用 reinterpret_cast 来完成，例如两个具体类型指针之间的转换、int 和指针之间的转换（有些编译器只允许 int 转指针，不允许反过来）。

下面的代码代码演示了 reinterpret_cast 的使用：

#include <iostream>
using namespace std;

class A{
public:
    A(int a = 0, int b = 0): m_a(a), m_b(b){}
private:
    int m_a;
    int m_b;
};

int main(){
    //将 char* 转换为 float*
    char str[]="http://c.biancheng.net";
    float *p1 = reinterpret_cast<float*>(str);
    cout<<*p1<<endl;  //3.0262e+29
    //将 int 转换为 int*
    int *p = reinterpret_cast<int*>(100);
    //将 A* 转换为 int*
    p = reinterpret_cast<int*>(new A(25, 96));
    cout<<*p<<endl; //25
    return 0;
}

可以想象，用一个 float 指针来操作一个 char 数组是一件多么荒诞和危险的事情，这样的转换方式不到万不得已的时候不要使用。将A*转换为int*，使用指针直接访问 private 成员刺穿了一个类的封装性，更好的办法是让类提供 get/set 函数，间接地访问成员变量。

Sec.IV dynamic_cast

dynamic_cast 与 static_cast 是相对的，dynamic_cast 是“动态转换”的意思，static_cast 是“静态转换”的意思。dynamic_cast 会在程序运行期间借助 RTTI 进行类型转换，这就要求基类必须包含虚函数；static_cast 在编译期间完成类型转换，能够更加及时地发现错误。

dynamic_cast 用于在类的继承层次之间进行类型转换，它既允许向上转型（Upcasting），也允许向下转型（Downcasting）。向上转型是无条件的，不会进行任何检测，所以都能成功；向下转型的前提必须是安全的，要借助 RTTI （Run Time Type Identification,通过运行时类型识别）进行检测，所有只有一部分能成功。
dynamic_cast 的语法格式为：

dynamic_cast <newType> (expression)

newType 和 expression 必须同时是指针类型或者引用类型。换句话说，dynamic_cast 只能转换指针类型和引用类型，其它类型（int、double、数组、类、结构体等）都不行。

对于指针，如果转换失败将返回 NULL；对于引用，如果转换失败将抛出std::bad_cast异常。

向上转型（Upcasting）

向上转型时，只要待转换的两个类型之间存在继承关系，并且基类包含了虚函数（这些信息在编译期间就能确定），就一定能转换成功。因为向上转型始终是安全的，所以 dynamic_cast 不会进行任何运行期间的检查，这个时候的 dynamic_cast 和 static_cast 就没有什么区别了。

#include <iostream>
#include <iomanip>
using namespace std;

class Base{
public:
    Base(int a = 0): m_a(a){ }
    int get_a() const{ return m_a; }
    virtual void func() const { }
protected:
    int m_a;
};

class Derived: public Base{
public:
    Derived(int a = 0, int b = 0): Base(a), m_b(b){ }
    int get_b() const { return m_b; }
private:
    int m_b;
};

int main(){
    //情况①
    Derived *pd1 = new Derived(35, 78);
    Base *pb1 = dynamic_cast<Base*>(pd1);
    cout<<"pd1 = "<<pd1<<", pb1 = "<<pb1<<endl;
    cout<<pb1->get_a()<<endl;
    pb1->func();

    //情况②
    int n = 100;
    Derived *pd2 = reinterpret_cast<Derived*>(&n);
    Base *pb2 = dynamic_cast<Base*>(pd2);
    cout<<"pd2 = "<<pd2<<", pb2 = "<<pb2<<endl;
    cout<<pb2->get_a()<<endl;  //输出一个垃圾值
    pb2->func();  //内存错误

    return 0;
}

情况①是正确的，没有任何问题。对于情况②，pd 指向的是整型变量 n，并没有指向一个 Derived 类的对象，在使用 dynamic_cast 进行类型转换时也没有检查这一点，而是将 pd 的值直接赋给了 pb（这里并不需要调整偏移量），最终导致 pb 也指向了 n。因为 pb 指向的不是一个对象，所以get_a()得不到 m_a 的值（实际上得到的是一个垃圾值），pb2->func()也得不到 func() 函数的正确地址。

pb2->func()得不到 func() 的正确地址的原因在于，pb2 指向的是一个假的“对象”，它没有虚函数表，也没有虚函数表指针，而 func() 是虚函数，必须到虚函数表中才能找到它的地址。

---

向下转型（Downcasting）
向下转型是有风险的，dynamic_cast 会借助 RTTI 信息进行检测，确定安全的才能转换成功，否则就转换失败。那么，哪些向下转型是安全地呢，哪些又是不安全的呢？下面我们通过一个例子来演示：

#include <iostream>
using namespace std;

class A{
public:
    virtual void func() const { cout<<"Class A"<<endl; }
private:
    int m_a;
};

class B: public A{
public:
    virtual void func() const { cout<<"Class B"<<endl; }
private:
    int m_b;
};

class C: public B{
public:
    virtual void func() const { cout<<"Class C"<<endl; }
private:
    int m_c;
};

class D: public C{
public:
    virtual void func() const { cout<<"Class D"<<endl; }
private:
    int m_d;
};

int main(){
    A *pa = new A();
    B *pb;
    C *pc;
   
    //情况①
    pb = dynamic_cast<B*>(pa);  //向下转型失败
    if(pb == NULL){
        cout<<"Downcasting failed: A* to B*"<<endl;
    }else{
        cout<<"Downcasting successfully: A* to B*"<<endl;
        pb -> func();
    }
    pc = dynamic_cast<C*>(pa);  //向下转型失败
    if(pc == NULL){
        cout<<"Downcasting failed: A* to C*"<<endl;
    }else{
        cout<<"Downcasting successfully: A* to C*"<<endl;
        pc -> func();
    }
   
    cout<<"-------------------------"<<endl;
   
    //情况②
    pa = new D();  //向上转型都是允许的
    pb = dynamic_cast<B*>(pa);  //向下转型成功
    if(pb == NULL){
        cout<<"Downcasting failed: A* to B*"<<endl;
    }else{
        cout<<"Downcasting successfully: A* to B*"<<endl;
        pb -> func();
    }
    pc = dynamic_cast<C*>(pa);  //向下转型成功
    if(pc == NULL){
        cout<<"Downcasting failed: A* to C*"<<endl;
    }else{
        cout<<"Downcasting successfully: A* to C*"<<endl;
        pc -> func();
    }
   
    return 0;
}

运行结果为：

Downcasting failed: A* to B*
Downcasting failed: A* to C*
-------------------------
Downcasting successfully: A* to B*
Class D
Downcasting successfully: A* to C*
Class D

这段代码中类的继承顺序为：A --> B --> C --> D。pa 是A*类型的指针，当 pa 指向 A 类型的对象时，向下转型失败，pa 不能转换为B*或C*类型。当 pa 指向 D 类型的对象时，向下转型成功，pa 可以转换为B*或C*类型。同样都是向下转型，为什么 pa 指向的对象不同，转换的结果就大相径庭呢？

这是因为：每个类都会在内存中保存一份类型信息，编译器会将存在继承关系的类的类型信息使用指针“连接”起来，从而形成一个继承链（Inheritance Chain），也就是如下图所示的样子：

当使用 dynamic_cast 对指针进行类型转换时，程序会先找到该指针指向的对象，再根据对象找到当前类（指针指向的对象所属的类）的类型信息，并从此节点开始沿着继承链向上遍历，如果找到了要转化的目标类型，那么说明这种转换是安全的，就能够转换成功，如果没有找到要转换的目标类型，那么说明这种转换存在较大的风险，就不能转换。

对于本例中的情况①，pa 指向 A 类对象，根据该对象找到的就是 A 的类型信息，当程序从这个节点开始向上遍历时，发现 A 的上方没有要转换的 B 类型或 C 类型（实际上 A 的上方没有任何类型了），所以就转换败了。对于情况②，pa 指向 D 类对象，根据该对象找到的就是 D 的类型信息，程序从这个节点向上遍历的过程中，发现了 C 类型和 B 类型，所以就转换成功了。

总的来说，dynamic_cast 会在程序运行过程中遍历继承链，如果途中遇到了要转换的目标类型，那么就能够转换成功，如果直到继承链的顶点（最顶层的基类）还没有遇到要转换的目标类型，那么就转换失败。对于同一个指针（例如 pa），它指向的对象不同，会导致遍历继承链的起点不一样，途中能够匹配到的类型也不一样，所以相同的类型转换产生了不同的结果。

从表面上看起来 dynamic_cast 确实能够向下转型，本例也很好地证明了这一点：B 和 C 都是 A 的派生类，我们成功地将 pa 从 A 类型指针转换成了 B 和 C 类型指针。但是从本质上讲，dynamic_cast 还是只允许向上转型，因为它只会向上遍历继承链。造成这种假象的根本原因在于，派生类对象可以用任何一个基类的指针指向它，这样做始终是安全的。本例中的情况②，pa 指向的对象是 D 类型的，pa、pb、pc 都是 D 的基类的指针，所以它们都可以指向 D 类型的对象，dynamic_cast 只是让不同的基类指针指向同一个派生类对象罢了。