C++类型转换

linken_xihe

已于 2025-01-23 12:42:05 修改

阅读量611

点赞数 17

文章标签： c++ 开发语言

于 2025-01-23 12:05:17 首次发布

本文链接：https://blog.youkuaiyun.com/hudong1984/article/details/145321029

版权

4、以{}方式初始化时进行的转换(c++11)

前言

c++中类型转换有些场景不需要程序员干预的情况下自动转换的，有默认规则，容易出错，整理总结如下。

隐式类型转换

c/c++编译器在不需要程序员显式干预的情况下，会将一种数据类型自动转化为另一种数据类型。类型转换发生在下面一些场景中。

1、初始化和赋值进行的转换

发生在将一种算术类型赋值给另一种算术类型的变量时。

将一个值赋给值取值范围更大的类型通常不会出问题，反之会截断、精度降低等问题。

2、算数运算进行的转换

发生在表达式中包含不同的类型时。

2.1、有些类型出现时便会自动转换。

在表达式时，c++将bool、char、unsigned char、signed char、short转化为int。这些转化称为整形提升。

short a = 1;
short b = 2;
short c = a + b; 
// 程序先将a、b转化为int,再将结果转化为short类型。
// int和CPU整数计算器(ALU)、CPU通用寄存器长度一致。效率较高。

2.2、其他类型C++11通过校验表来确定在算术表达式中执行的转化。

2.2.1、其中有一个是long double，则将另一个操作转化成long double。

2.2.2、其中有一个是double，则将另一个操作转化成double。

2.2.3、其中有一个是float，则将另一个操作转化成float。

2.2.4、不是上面三种情况，进行整型提升。

2.2.5、如果都是无符号或有符合，级别低的转换为高的类型。

2.2.6、如果一个无符号，一个有符号，且无符号操作数的级别比有符号操作数级别高，都转化成无符号。

2.2.7、否则，如果有符合可表示无符号类型的所有可能取值，则将无符号转换为有符号操作所属的类型。

2.2.8、否则，将两个操作数都转换为有符号类型的无符号版本。？

有符号/无符号整型级别高到低：long long、long、int、short、signed char。char、signed char、unsigned char级别相同，bool最低。

3、函数调用进行的转换

发生在将参数传递给函数时。

传递参数时的类型转换通常有C++函数原型控制。

4、以{}方式初始化时进行的转换(c++11)

列表初始化不允许缩窄(narrowing)。

显式类型转换

c语言中的转换太过松散，C++11提供了四种显式类型转换。

1、static_cast

#include <iostream>
#include <typeinfo>

using namespace std;

class clsBase
{
    public:
        virtual void f0() 
        {
            void (clsBase::*funcPtr)() = &clsBase::f0;

            cout << typeid(*this).name() << "->" << __FUNCTION__ 
                << "->address:" << (void*)funcPtr << endl;        
        }      
};

class clsFather : public clsBase
{
    public:
        virtual void f0() 
        {
            // 获取当前成员函数 f0 的地址
            void (clsFather::*funcPtr)() = &clsFather::f0;

            cout << typeid(*this).name() << "->" << __FUNCTION__ 
                << "->address:" << (void*)funcPtr << endl;
        }
};

int main()
{
    // 1、基本类型之间的转换
    int a = 1;
    float b = static_cast<float>(a);
    cout << "a->" << a << " b->" << b << endl;

    // 2、类层次结构中，父类子类之间的转换。
    // C++ 中的类型转换并不会改变对象的实际内存布局，也不会改变对象的实际类型。它只是改变了编译器对该对象的“视角”，即如何解释这个对象。
    clsFather clsFather_;

    // 2.1、向上转换安全
    clsBase* clsBase_  = static_cast<clsBase*>(&clsFather_);
    clsBase_->f0();

    // 2.2、向下转换需要确保安全性
    clsFather *clsFather__ = static_cast<clsFather*>(clsBase_);
    clsFather__->f0();

    return 0;
}

2、dynamic_cast

#include <iostream>
#include <typeinfo>

using namespace std;

class clsBase
{
    public:
        virtual void f0() 
        {
            void (clsBase::*funcPtr)() = &clsBase::f0;

            cout << typeid(*this).name() << "->" << __FUNCTION__ 
                << "->address:" << (void*)funcPtr << endl;        
        }
};

class clsFather : public clsBase
{
    public:
        virtual void f0() 
        {
            // 获取当前成员函数 f0 的地址
            void (clsFather::*funcPtr)() = &clsFather::f0;

            cout << typeid(*this).name() << "->" << __FUNCTION__ 
                << "->address:" << (void*)funcPtr << endl;
        }
};

int main()
{
    // 主要用于类层次结构中指针或引用的转换。它依赖于运行时类型信息（RTTI）,所以必须有virtual函数。
    // 1、主要用于从基类指针或引用转换为子类指针或引用（向下转换）。
    clsBase *clsBase_ = new clsFather();
    clsFather *clsFather_ = dynamic_cast<clsFather*>(clsBase_);

    clsFather_->f0();

    return 0;
}

3、const_cast

多用于接口兼容或修改原始对象不是 const 的情况

#include <iostream>

using namespace std;

void modifyConstValue(const int* value)
{
    int *t = const_cast<int *>(value);

    *t = 30;

    cout << __FUNCTION__ << " t->" << *t << endl;
}

int main()
{
    // case 1
    {
        int a = 20;
        
        cout << "before a->" << a << endl;
        const int *tmp = &a;
        modifyConstValue(tmp);    
        cout << "after a->" << a << endl;
    }

    // case 2
    {
        const int b = 40;
        cout << "before b->" << b << endl;
            const int *tmp = &b;
        modifyConstValue(tmp);    
        cout << "after b->" << b << endl; // 未定义行为，有很多不确定性。
    }

    return 0;
}

4、reinterpret_cast

用于进行低级别、无类型安全检查的转换。谨慎使用。

#include <iostream>

using namespace std;

int main() 
{
    int a = 42;

    void* voidPtr = reinterpret_cast<void*>(&a); // 转换为void*
    int* intPtr = reinterpret_cast<int*>(voidPtr); // 转回int*
    cout << "Value: " << *intPtr << endl;

    return 0;
}

补充

explicit 禁用隐式转换