C++ 显示类型转换——4种强制类型转换

最新推荐文章于 2022-08-06 16:04:44 发布
原创 最新推荐文章于 2022-08-06 16:04:44 发布 · 置顶 · 798 阅读 · 1 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#c++

本文详细介绍了C++中的四种强制类型转换：static_cast用于内置类型和具有明确定义转换的自定义类型；dynamic_cast主要用于类层次间的指针或引用转换，添加和删除底层const；const_cast用于改变对象的const属性；reinterpret_cast用于低层次的位模式重新解释，但使用需谨慎。

C++ 显示类型转换——4种强制类型转换

​ 强制类型转换，顾名思义，就是将变量或对象通过一定方法显示地进行类型转换的措施。强制类型转换并不改变原对象类型，只是通过原对象生成新的对象。在 C++ 中，一共有 4 种强制类型转换的操作，其分别是：static_cast<newType>,const_cast<newType>, reinterpret_cast<newType> 及dymatic_cast<newType>，其分别用于不同的情况下。

1. static_cast<newType>

  • 用于任何具有明确定义的类型转换，但是无法去掉底层 const (可以加上底层 const)。
  • 用于编译器无法自动执行的类型转换。

​ 首先来看第一点，C++中包含的类型分为指针，内置算术类型及自定义类型，指针不具有明确定义的类型转换，内置算术类型具有明确定义的类型转换，而自定义类型需要借助可以只传递一个参数的构造函数，或者类型转换运算符来具有明确定义的类型转换。

例 1 内置算术强制类型转换

#include <iostream>
#include <typeinfo>

using namespace std;

int main()
{
	int value = 5;
	cout << typeid(static_cast<double>(value)).name() << endl; // 通过类型转换生成临时变量
	cout << typeid(value).name() << endl; // 原对象
	return 0;
}

结果如下：

在这里插入图片描述

例 2 自定义类型强制类型转换

​ 考虑如下代码，因为没有在 SecondType 中没有可以只接受 FirstType 类型参数的构造函数或者在FirstType 中没有对应的类型转换运算符使得该类型具有明确定义的类型转换，所以无法通过 static_cast<newType> 完成类型转换。

#include <iostream>
#include <typeinfo>

using namespace std;

class FirstType
{
private:
    int val_;
};

class SecondType
{
private:
    int val_;
};

int main()
{
    FirstType firstType;
    static_cast<SecondType>(firstType);
	return 0;
}

结果如下：
在这里插入图片描述

​ 倘若为其加上适当的构造函数或者类型转换运算符，此时该自定义类型便具有明确定义的类型转换，则可实现强制转换的功能：

#include <iostream>
#include <typeinfo>

using namespace std;

class FirstType;

class SecondType
{
public:
    SecondType(int val) : val_(val) {}
    explicit SecondType(const FirstType& firsType) : val_(0) {} // 2 选 1 即可
private:
    int val_;
};

class FirstType
{
public:
    operator SecondType() const // 2 选 1 即可
    {
        return SecondType(val_);
    }
private:
    int val_;
};

int main()
{
    FirstType firstType;
    cout << typeid(static_cast<SecondType>(firstType)).name() << endl;
	return 0;
}

结果如下：

在这里插入图片描述

例 3 无法去掉底层const

#include <iostream>
#include <typeinfo>

using namespace std;

int main()
{
    const int val = 5;
    const int* ptr = &val;
    cout << typeid(static_cast<int*>(ptr)).name() << endl; // 无法去掉底层 const
	return 0;
}

结果如下：

在这里插入图片描述
例 4 可以添加底层 const

#include <iostream>
#include <typeinfo>

using namespace std;

int main()
{
    int val = 5;
    int* ptr = &val;
    cout << typeid(static_cast<const int*>(ptr)).name() << endl;
	return 0;
}

结果如下：
在这里插入图片描述

​ 然后说一下第二点，用于编译器无法自动执行的类型转换，对于此点，目前我了解到的只有关于void*的转换，对于void*，编译器无法知道其所指对象的真正类型，也就无法自动执行类型转换，因此可以将void*转化为任意类型指针。同样，也可以将任意类型指针转换为void*指针。

例 5 将void*转化为任意类型指针，并将任意类型指针转换为 void*指针

#include <iostream>
#include <typeinfo>

using namespace std;

int main()
{
    int value = 1;
    void* ptr = &value;
    int* ptrI = &value;
    
    cout << typeid(static_cast<int*>(ptr)).name() << endl; // void* --> 其他类型指针
    cout << typeid(static_cast<void*>(ptrI)).name() << endl; // 其他类型指针 --> void*
	return 0;
}

结果如下：
在这里插入图片描述

2. const_cast<newType>

  • 只能用于改变运算对象的底层const，即添加或删除底层const属性。

例 6 添加底层 const 及删除底层 const

#include <iostream>
#include <typeinfo>

using namespace std;

int main()
{
    const int value = 2;
    const int* cptr = &value;
    int* ptr = const_cast<int*>(cptr); // 删除底层 const
    const int* cptr1 = const_cast<const int*>(ptr); // 添加底层 const

    cout << typeid(cptr).name() << endl;
    cout << typeid(ptr).name() << endl;
    cout << typeid(cptr1).name() << endl;

    return 0;
}

结果如下：
在这里插入图片描述

3. reinterpret_cast<newType>

  • 为运算对象的位模式提供较低层次上的重新解释，转换前后其bit完全相同。其中 newType必须为指针、引用、算术类型。通常用于指针之间的转换，或者指针和整数类型之间转换。

例 6 指针间转换，指针和整数类型转换（64bit 机器下测试）

#include <iostream>
#include <typeinfo>

using namespace std;

int main()
{
    int value = 2;
    long int* ptr = reinterpret_cast<long int*>(&value); // 将 int* 转换为 long int*
    long int ptrValue = reinterpret_cast<long int>(&value); // 将 int* 转换为 long int

    cout << "sizeof(int) = " << sizeof(int) << " " 
         << "sizeof(long int) = " << sizeof(long int) << endl;

    cout << "value = " << value << endl;
    cout << "*ptr = " << *ptr << endl; // 容易造成错误

    cout << "&value = " << &value << endl;
    cout << "ptrValue = " << hex << ptrValue << endl;

    return 0;
}

结果如下：
在这里插入图片描述

​ 可以看出在进行指针转换时，int 所占空间为 4 bytes，而long int 为 8 bytes，在用 ptr 进行读数据时会导致其通过 long int 的方式读了 8 bytes 的数据，从而导致不可预料的错误。除此以外 reinterpret_cast还可能造成其它危害。所以在日常使用中，不建议使用 reinterpret_cast。

​ 那如何在不用 reinterpret_cast的情况下对指针类型之间进行转换呢？答案是用static_cast，其思路如下图：

指针类型1
void*
指针类型2

例 7 sockaddr_in* 转换至sockaddr*

#include <netinet/in.h>
#include <iostream>
#include <typeinfo>

using namespace std;

sockaddr* sockaddr_cast(sockaddr_in* addr4)
{
    return static_cast<sockaddr*>(static_cast<void*>(addr4));
}

int main()
{
    sockaddr_in addr4;
    sockaddr* addr = sockaddr_cast(&addr4);

    cout << typeid(&addr4).name() << endl;
    cout << typeid(addr).name() << endl;

    return 0;
}

结果如下：
在这里插入图片描述

4.dymatic_cast<newType>

dymatic_cast 的主要使用形式如下：

dymatic_cast<newType>(e)

​ 其中 newType 必须为指针，左值引用及右值引用。对于指针类型而言，若强制类型转换成功，则返回对应指针，否则返回 nullptr。对于引用类型而言，若强制转换成功，则返回对应引用，若转换失败，则抛出std::bad_cast异常。使用dymatic_cast必须符合以下三个条件之一：

  • e 是 newType 的公有派生类，即 e 和 newType 是 is a 的关系；

  • newType 是 e 的公有派生类，即 newType 和 e 是 is a 的关系，且 e 的类中必须至少包含一个虚函数。

  • newType 和 e 是同类型。

例 8 父子类相互转换

转换成功：

#include <iostream>

using namespace std;

class Base
{
public:
    virtual ~Base() {}
public:
    int val_;
};

class Derived : public Base
{
public:
};

int main()
{
    Derived derived;
    
    Base* basePtr = dynamic_cast<Base*>(&derived); // 基类指针指向派生类对象
    Derived* derivedPtr = dynamic_cast<Derived*>(basePtr); // 基类指针转换为派生类指针

    cout << "basePtr = " << basePtr << endl;
    cout << "derivedPtr = " << derivedPtr << endl;

    return 0;
}

结果如下：
在这里插入图片描述
​ 基类指针转换为派生类指针成功的原因为basePtr本身就是指向derived对象，所以可以将其转换成derived*。否则转换失败。

转换失败：

#include <iostream>

using namespace std;

class Base
{
public:
    virtual ~Base() {}
public:
    int val_;
};

class Derived : public Base
{
public:
};

int main()
{
    Base base;
    Derived derived;
    
    Base* basePtr = dynamic_cast<Base*>(&derived); // 基类指针指向派生类对象
    Derived* derivedPtr = dynamic_cast<Derived*>(&base); // 基类指针转换为派生类指针

    cout << "basePtr = " << basePtr << endl;
    cout << "derivedPtr = " << derivedPtr << endl;

    return 0;
}

结果如下：
在这里插入图片描述

总结

  • 对于算术类型和具有明确定义的类型转换的自定义类型，用 static_cast 来完成转换。对于指针类型转换，通过将其转换为void*，再转换为其它指针类型完成。

  • 对于添加和删除底层const操作，采用const_cast来完成。

  • 在日常中，尽量不要用 reinterpret_cast。

  • 在涉及基类和派生类之间转换的时候，采用dymatic_cast来完成。

C++递归遍历文件夹内的所有文件夹与文件（附完整源码）
dvlinker的技术专栏
07-26 961
C++递归遍历文件夹内的所有文件夹与文件
C++新特性（二）更安全的强制类型转换
weixin_42445051的博客
01-26 3638
C语言原来有简单的语法实现强制类型转换，为什么C++还要确定新特性实现强制类型转换呢？归根到底是因为C语言强制类型转换有以下三个缺点。 1，没有从形式上体现转换功能和风险的不同。 例如，将int强制转换成double是没有风险的，而将常量指针转换成非常量指针,将基类指针转换成派生类指针都是高风险的，而且后两者带来的风险不同(即可能引发不同种类的错误) , C语言的强制类型转换形式对这些不同并不加以区分。 2，将多态基类指针转换成派生类指针时不检查安全性，即无法判断转换后的指针是否确实指向一个派生类对象。 3
四种强制类型转换
ajdjirkdnkfk的博客
12-18 281
四种强制类型转换 1. static_cast 用于基本类型转换，和子类向父类转换 2. const_cast 用于去除指向常数的指针和引用的const属性 3. dynameic_cast 用于父类向子类的转换，转换失败返回0,用于继承而且必须有虚函数不然编译报错 4. reinterpret_cast 不想关类型的转换 ...
C++显示类型转换
红心地瓜的专栏
11-12 5543
reinterpret_cast,static_cast,const_cast,dynamic_cast等C++显示转换运算符
C++的显式类型转换
HAN Kai
09-04 938
static_cast For “well-behaved” and “reasonably well-behaved” casts, including things you might now do without a cast (such as an automatic type conversion). const_cast To cas
C++ 四种类型转换运算符
weixin_45743799的博客
03-19 346
隐式类型转换是安全的，显式类型转换是有风险的，C语言之所以增加强制类型转换的语法，就是为了强调风险，让程序员意识到自己在做什么。 但是，这种强调风险的方式还是比较粗放，粒度比较大，它并没有表明存在什么风险，风险程度如何。再者，C风格的强制类型转换统一使用( )，而( )在代码中随处可见，所以也不利于使用文本检索工具定位关键代码。 为了使潜在风险更加细化，使问题追溯更加方便，使书写格式更加规范，C+...
C++学习——数据类型（强制）转换详解
流楚丶格念的博客
04-03 7126
有时，编程的过程中需要将值从一种数据类型转换为另一种数据类型。C++ 提供了这样做的方法。 如果将一个浮点值分配给一个 int 整型变量，该变量会接收什么值？如果一个 int 整数乘以一个 float 浮点数，结果将会是什么数据类型？如果一个 double 浮点数除以一个 unsigned int 无符号整数会怎么样？是否有办法预测在这些情况下会发生什么？ 答案是肯定的。当运算符的操作数具有不同的...
精选资源
C强制类型转换-C教程共5页.pdf.zip
11-22
在C++中，有一种更安全的强制类型转换方式——static_cast，它用于基本类型之间的转换以及派生类向基类的转换。虽然在纯C语言中不常见，但理解其概念对于学习C++是有帮助的。 5. 类型转换的使用场景： - 数据库...
C++基础(一)——数据类型及其转换
花于陌上开的博客
01-29 893
C++学习基础(一)——数据类型及其转换
每天一点C++——C++中的强制类型转换
itlilyer的博客
08-06 572
C/C++强制类型转换介绍
c++显示类型转换
york_software的专栏
10-07 432
<br /><br />由于c＋＋有多重继承甚至是虚基类，所以提供一套显示的类型转换有助于提高代码质量，也容易阅读。其中最有有用的自然是dynamic_cast，但需要rtti的支持（typeid也是一样）。其余有const_cast reinterpret_cast ， static_cast，其实除了dynamic_cast中把基类指针和引用专程子类指针和引用时需要判断此基类指针是否指向子类外，其他的显示转换都可以用C中的隐式转换完成。<br />1.dynamic_cast<type>: type只能
C++【显示类型转换】
志存高远
10-28 793
显示类型转换 C：目标类型变量 = (目标类型)源类型变量; int n; char c; c = (char)n; C++：五种转换形式 1.C风格的另一种写法 目标类型变量 = 目标类型 (源类型变量); int n; char c; c = char (n); 2.静态类型转换：static_cast<目标类型> int n; char c; c = static_
C++ 中的cast（显式类型转换）
一叶舟轻
10-19 1760
这篇文章的目的是简单介绍 C++ 的类型转换系统，并对使用和扩展进行一些讨论。转自：http://www.polyrandom.com/C++ 引入了 const_cast, reinterpret_cast 之类的新的显式类型转换方式，不仅大多数 C 程序员觉得不是很习惯，就连某些有经验的C++ 程序员都会在一些细节上犯错。诚然，既然我们可以简单的写出：int i = (int)p;//
C++中的显示类型转换
Nire_Yeyu的博客
09-13 1247
一、静态类型转换 目标类型 变量 = static_cast<目标类型>(源对象) 使用场合： 如果源对象和目标类型对象任何一方可以进行隐式类型转换，那么两边都可以进行静态类型转换 例如：char 可以隐式转换成 int；int* 可以隐式转换成 void* 则：这两者可使用静态类型转换 #include <iostream> using namespace std;...
STL_3: 类别转换操作符
LandscapeMi
12-16 410
http://www.cnblogs.com/BeyondAnyTime/archive/2012/08/23/2652696.htmlstatic_cast 最常用的类型转换符，在正常状况下的类型转换，如把int转换为float，如 int i; float f; f=(float)i; 或者 f=static_cast<float>(i)const_cast 用于取出const属性，把const
C++中显示的类型转换
zhuo_wang的专栏
09-28 708
C++是希望用户能够尽最大的定义正确的类型，而少用显示的类型转换，以致不用显示的类型转换 /*  *C++显示的强制类型转换，区别与C  *static_cast --- 数值类型之间、有一方是void* 的指针类型之间  *const_cast  --- 用于临时去掉const、volatile限制  *reinterpret_cast --- 任意两种指针类型之间，指针与数值类型之间
C++四种类型转换详解及安全使用技巧
这些运算符取代了C语言中不安全的强制类型转换方式，提供了更清晰、更可控、更具语义表达能力的类型操作机制。 首先，**static_cast** 是最常用且相对安全的类型转换方式，适用于“相关”类型之间的显式转换。这里...
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值