c++中的类型转换

目录

　　1. 隐式类型转换

　　2. 强制类型转换（ static_cast、const_cast、reinterpret_cast、dynamic_cast）

　　3. 类型转换函数、转换构造函数

　　类型转换可分为 隐式类型转换（编译器自动完成） 与 强制类型转换（需要自己操作）。

隐式类型转换　　

　　基本数据类型之间会进行隐式的类型安全转换。其转换规则如下：

　　

 　　我们用 1个案列来介绍这种隐式类型转换规则，会有意想不到的结果发生....!!!

#include <iostream>
#include <string>

using namespace std;

int main()
{   
    short s = 'a';
    unsigned int ui = 1000;
    int i = -2000;
    double d = i;
    
    cout << "d = " << d << endl;
    cout << "ui = " << ui << endl;
    cout << "ui + i = " << ui + i << endl;
    
    if( (ui + i) > 0 )  // 变量i会进行隐式类型转换 -> unsigned int  // ui + i > 0
    {
        cout << "Positive" << endl;
    }
    else
    {
        cout << "Negative" << endl;
    }
    
    cout << "sizeof(s + 'b') = " << sizeof(s + 'b') << endl;    // 4 // s -> int  'b' -> int // sizeof(s + 'b') = sizeof(int) // 编译器默认是int运算
    
    return 0;
}
/*
    d = -2000
    ui = 1000
    ui + i = 4294966296
    Positive
    sizeof(s + 'b') = 4
*/

　　在c++中，还有其它几种隐式类型转换（后续讲解），那么现在试想一下这几个问题：

　　　　1. 基本类型 可以转换为 类类型吗？--- 可以，见转换构造函数；

　　　　2. 类类型 可以转换为 基本类型吗？--- 可以，见类型转换函数；

　　　　3. 类类型之间可以转换吗？--- 可以，见转换构造函数 和 类型转换函数；

　　注：这种隐式类型转换不能够抑制，并且也是bug的来源之一；

强制类型转换

　　在介绍c++强制类型转换前，我们可以回顾一下c语言中的强制类型转换。c语言中的强制类型转换十分简单、粗暴，即 (Type)(Expression)；或者 Type(Expression)；但是，这种简单的强制类型转换引发了很多问题，可归纳为如下2点：

　　1. 任意类型之间都可以进行转换，编译器很难判断其正确性（过于粗暴）；

　　2. 在源码中无法快速定位所有使用强制类型转换的语句（很难定位）；

所以，基于这2点考虑，在c++中引入了新式类型转换（ static_cast、const_cast、reinterpret_cast、dynamic_cast），其使用方法可归纳为 xxx_cast<Type>(Expression) 。

1、static_cast

　　1. 用于 基本类型间的转换

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

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

　　4. 用于 其它类型（基本类型和类类型） 向 类类型之间的转换；static_cast<类类型>(其它类型)，见转换构造函数。

2、 const_cast

　　1. 用于去除变量的只读属性

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

3、 reinterpret_cast

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

　　2. 用于整数和指针类型间的强制转换

4、 dynamic_cast

　　1. 用于有继承关系的类指针（引用）间的转换

　　2. 用于有交叉关系的类指针（引用）间的转换

　　3. 相关类（基类）中必须有虚函数的支持

　　4. 具有类型检查的功能，但类型转换的结果只可能在运行阶段得到；

　　指针转换：

　　　　转换成功：得到目标类型的指针；

　　　　转换失败：得到一个空指针；

　　引用转换：　

　　　　转换成功：得到目标类型的引用；

　　　　转换失败：得到一个异常操作的信息；

　　dynamic_cast 转换时错误提示：

　　　　1. 不能将父类指针 直接 转换为 子类指针

　　　　　　

　　　　　　  

 　　　　2. 在 父类中没有虚函数，不能发生多态 polymorphic

　　　　　　

 　　　　　　

#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);    // error static_cast 不能用于基本类型指针之间 的转换
}

void const_cast_demo()
{
    const int& j = 1;
    int& k = const_cast<int&>(j);
    
    const int x = 2;
    int& y = const_cast<int&>(x);
    
    int z = const_cast<int>(x);     // error const_cast 强制转换的目标类型必须是指针或引用类型
    
    k = 5;
    
    printf("k = %d\n", k);  // 5
    printf("j = %d\n", j);  // 5
    
    y = 8;
    
    printf("x = %d\n", x);  // 2
    printf("y = %d\n", y);  // 8
    printf("&x = %p\n", &x);// 0x7fffd40b84e8
    printf("&y = %p\n", &y);// 0x7fffd40b84e8
}

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);  // error reinterpret_cast 适用于指针类型之间的转换  和 整型与指针类型之间的转换
}

void dynamic_cast_demo()
{
    int i = 0;
    int* pi = &i;
    char* pc = dynamic_cast<char*>(pi); // error
}

int main()
{
    static_cast_demo();
    const_cast_demo();
    reinterpret_cast_demo();
    dynamic_cast_demo();
    
    return 0;
}

 

#include <iostream>
#include <string>

using namespace std;

class Base
{
public:
    Base()
    {
        cout << "Base::Base()" << endl;
    }
    
    virtual ~Base()
    {
        cout << "Base::~Base()" << endl;
    }
};

class Derived : public Base
{
public:
    Derived()
    {
        cout << "Derived::Derived()" << endl;
    }
    
    void func()
    {
        cout << "Derived::func()" << endl;
    }
    
    virtual ~Derived()
    {
        cout << "Derived::~Derived()" << endl;
    }
};

void test1()
{
    Base* bp = new Derived();
    
    Derived *dp = dynamic_cast<Derived*>(bp);   // 当父类指针指向的是子类对象，转换成功
    //Derived *dp = static_cast<Derived*>(bp);  // 当父类指针指向的是子类对象，转换成功
    if( dp != NULL )
    {
        cout << "dp = " << dp << endl;
        dp->func();
    }
    else
    {
        cout << "Cast error!" << endl;
    }
    
    delete bp;
}

void test2()
{
    Base* bp = new Base();
    
    Derived *dp = dynamic_cast<Derived*>(bp);   // 转化失败，不能将父类指针对象转换为子类指针对象
    //Derived *dp = static_cast<Derived*>(bp);     // 转换成功，可以将父类指针对象转换为子类指针对象，但可能有 Bug 存在
    if( dp != NULL )
    {
        cout << "dp = " << dp << endl;
        dp->func();
    }
    else
    {
        cout << "Cast error!" << endl;
    }
    
    delete bp;
}

int main()
{
    test1();
    
    cout << "-----------------------" << endl;
    
    test2();

    return 0;
}

　　通过 《 static_cast 与 dynamic_cast 测试案列 》可知，当使用 dynamic_cast 强制类型转换时，即 Derived *dp = dynamic_cast<Derived*>(bp); 程序的运行结果为：

　　        

 　　当使用 static_cast 强制类型转换时，即 Derived *dp = static_cast<Derived*>(bp); 程序的运行结果为：

　　       

　　从运行结果可知， static_cast 与 dynamic_cast 在继承中进行类指针转换时是存在差异的；其中，

　　　　1. 相同点：当父类指针 指向 子类对象时，二者都可以将父类指针 成功转换为 子类指针；

　　　　　　

 　　　　2. 不同点：当父类指针 指向 父类对象时，

　　　　　　1） static_cast 转换：可以将父类指针 成功转换为 子类指针；

　　　　　　2）dynamic_cast 转换：父类指针 不能够转换为  子类指针；

　　　　　　 

　　对于 static_cast 与 dynamic_cast 的使用情况还可以查阅另一篇博客 《 c++中的类型识别 》中的 如何实现动态类型 这一节。

类型转换函数

1、转换构造函数

　　当构造函数只有1个参数 且 参数的类型是基本类型 或者是 其它类型时，就是转换构造函数。其作用是将其他类型 转换为 类类型；

　　编译器尽力尝试的结果是隐式类型转换，隐式类型转换是工程中bug的重要来源；

　　工程中通过explicit关键字杜绝隐式转换，转换构造函数被explicit修饰时只能进行显示转换；

　　转换方式

　　1. static_ cast<ClassName >(value)；

　　2. ClassName(value)；

　　3. (ClassName)value； //不推荐

　　在类型转换时调用转换构造函数。

         

#include <iostream>
#include <string>

using namespace std;

class Test
{
    int mValue;
public:
    Test()
    {
        mValue = 0;
    }
    
    explicit Test(int i)
    {
        mValue = i;
    }
    
    Test operator + (const Test& p)
    {
        Test ret(mValue + p.mValue);
        
        return ret;
    }
    
    int value()
    {
        return mValue;
    }
};

int main()
{   
    Test t;
    Test r;
    
    // 隐式类型转换 不加explicit关键字
    //t = 5;        // t = Test(5);
    //r = t + 10;   // r = t + Test(10);
    
    t = static_cast<Test>(5);    // t = Test(5);    
    r = t + static_cast<Test>(10);   // r = t + Test(10);
    
    cout << r.value() << endl;  // 15
    
    return 0;
}

2、类型转换函数

 　　c++ 中可以定义类型转换函数，其作用是将 类类型 转换为 其它类型；其语法格式为：

// 类型转换函数语法格式
operator Type()
{
     Type ret;

     // ...
  
     retuan Type;
}

　　编译器能够隐式的使用类型转换函数

　

#include <iostream>
#include <string>

using namespace std;

class Test
{
    int mValue;
public:
    Test(int i = 0)
    {
        mValue = i;
    }
    int value()
    {
        return mValue;
    }
    operator int ()
    {
        return mValue;
    }
};

int main()
{   
    Test t(100);
    int i = t;  // 隐式的使用类型转换函数 operator int ()
    
    cout << "t.value() = " << t.value() << endl;    // t.value() = 100
    cout << "i = " << i << endl;    // i = 100
    
    return 0;
}

3、类型转换函数  VS  转换构造函数　

　　结论：

　　1. 类型转换函数 与 转换构造函数 具有同等的地位；

　　2. 无法抑制隐式的类型转换函数调用，此时 类型转换函数可能与转换构造函数冲突（类类型之间的转换）；

　　3. 在类型转换时 调用类型转换函数 、转换构造函数。

　　4. 工程中以Type toType()的公有成员 代替 类型转换函数；

　　　　

#include <iostream>
#include <string>

using namespace std;

class Test;

class Value
{
public:
    Value()
    {
    }
    explicit Value(Test& t)
    {
        cout << "explicit Value(Test& t)" << endl;
    }
};

class Test
{
    int mValue;
public:
    Test(int i = 0)
    {
        mValue = i;
    }
    int value()
    {
        return mValue;
    }
    operator Value()
    {
        Value ret;
        cout << "operator Value()" << endl;
        return ret;
    }
};

int main()
{   
    Test t(100);
    Value v1 = t;    // 隐式的调用类型转换函数 operator Value()
    Value v2 = static_cast<Value>(t);    // 显示的调用转换构造函数 explicit Value(Test& t)
    
    return 0;
}
/*
    运行结果：
    operator Value()
    explicit Value(Test& t)
*/

      //  类型转换函数与转换构造函数发生冲突   的示意图