C++的类型转换

最新推荐文章于 2022-09-12 09:58:40 发布

翻译最新推荐文章于 2022-09-12 09:58:40 发布 · 288 阅读

c++ 专栏收录该内容

8 篇文章

订阅专栏

前言

在看到C++中static_cast等东东的时候，不知道这个代表什么，然后就对C++产生了一点惧怕，原来还以为是模板里的东西，所以把模板学了学，后来才发现是类型转换用的。
学习！分享！感谢！

C++中的类型转换

类型转换名称和语法

C风格的强制类型转换(Type Cast)很简单，不管什么类型的转换统统是：

TYPE b = (TYPE)a

C++风格的类型转换提供了4种类型转换操作符来应对不同的场合的应用。

static_cast    静态类型转换。如int转换成char。静态类型转换，编译时C++编译器会做类型检查，基本类型能转换，但是不能转换指针类型
reinterpreter_cast 重新解释类型。如int转换成int*，强制类型转换
dynamic_cast 命名上理解是动态类型转换。如子类和父类之间的多态类型转换
const_cast 字面理解就是去const属性

4种类型转换的格式：

TYPE B = static_cast<TYPE> (a)

`static_cast`用法和`reinterpret_cast`用法

int main()
{
    double dPi = 3.1415926;

    int num1 = (int)dPi; // c
    int num2 = static_cast<int>(dPi);   // 静态类型转换 编译时c++编译器会做类型检查
    int num3 = dPi; // c语言中隐式类型转换的地方 均可使用 static_cast<>()进行类型转换

    // char* -> int*
    char *p1 = "hello";
    int *p2 = NULL;
//    p2 = p1;
//    p2 = static_cast<int*>(p1);  // 静态类型转换 编译时c++编译器会做类型检查
    p2 = reinterpret_cast<int*>(p1);

    cout << p1 << endl;
    cout << p2 << endl; // 打印内存地址

    cout << "Hello world!" << endl;
    return 0;
}

`dynamic_cast`用法和`reinterpret_cast`用法

//　抽象类
class animal
{
public:
    virtual void cry() = 0;
};

class dog: public animal
{
public:
    virtual void cry()
    {
        cout << "wangwang" << endl;
    }
    void doHome()
    {
        cout << "doHome" << endl;
    }
};

class cat : public animal
{
public:
    virtual void cry()
    {
        cout << "miaomiao" << endl;
    }
    void doHome()
    {
        cout << "catch" << endl;
    }
};

class tree
{
public:

};

void playObj(animal* base)
{
    base->cry();    // 继承 虚函数重写 父类指针指向子类对象
    // 识别子类对象
    // dynamic_cast 运行时类型识别，如果类型正确返回指针，错误返回NULL
    dog* pDog = dynamic_cast<dog*>(base);
    if(pDog != NULL)
    {
        pDog->doHome(); // 判断是哪个子类对象，执行子类对象指定函数
    }

    cat* pCat = dynamic_cast<cat*>(base);   // 父类对象转换为子类对象 向下转型
    if(pCat != NULL)
    {
        pCat->doHome();
    }
}

int main()
{
    dog d1;
    cat c1;

    animal* pBase = NULL;
    // 可以把子类指针指向父类，但是反过来不可以需要，如下转换
    //pdog = base;  // error
    //Dog *pDog = static_cast<Dog *> (base);

    pBase = &d1;    // 父类指针指向子类对象
    pBase = static_cast<animal*>(&d1);
    pBase = reinterpret_cast<animal*>(&d1);

    tree t1;
    // static_cast转换动物类为其他类错误，reinterpret_cast可以
//    pBase = static_cast<animal*>(&t1);  // static_cast会进行类型检查，因为类型不同，所以会出现错误
    pBase = reinterpret_cast<animal*>(&t1);


    playObj(&d1);
    playObj(&c1);

    return 0;
}

const_cast用法

// const 指向的内存空间变成只读
void printBuf(const char* p)
{
//    p[0] = 'z';
    char* p1 = NULL;
    p1 = const_cast<char*>(p);
    p1[0] = 'z';

    cout << p << endl;
}

int main()
{
    char buf[] ="simon";
//    char *buf = "simon";    // 这种const不起作用

    // 程序员确保所指向的内存空间确实能修改;如果不能修改就会程序崩溃
    printBuf(buf);

    return 0;
}