C++四种强制类型转换运算符

最新推荐文章于 2024-07-05 16:15:03 发布
最新推荐文章于 2024-07-05 16:15:03 发布
阅读量4.3k 收藏 17
点赞数 3
分类专栏： C/C++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/chen1415886044/article/details/104565863
版权

C/C++中的类型转换分为两种：隐式类型转换和显式类型转换。

而对于隐式类型转换，在很多时候，不经意间就发生了，比如int类型和float类型赋值时，int类型就会被隐式的转换位float类型。

举例：

int i = 5;
float d = i;//隐式类型的转换
int* p = (int*)i;//C style，强制类型的转换.

C++对C兼容，所以上述方式的类型转换是可以的，但是有时候会有问题，所以推荐使用C++中的四个强制类型转换的关键字：
static_cast、reinterpret_cast、const_cast 和 dynamic_cast。下面将逐一介绍。

static_cast

这应该四种中是最常见的。用法为：

static_cast < new_type > ( expression )

该运算符把 expression 转换为new_type 类型。

特点：

1、 用于非多态类型的转换
2、 不执行运行时类型检查（转换安全性不如 dynamic_cast）
3、通常用于转换数值数据类型（如 float -> int）
4、 可以在整个类层次结构中移动指针，子类转化为父类安全（向上转换），父类转化为子类不安全（因为子类可能有不在父类的字段或方法）

通常用于转换数值数据类型（如 float -> int）：


#include <iostream>

using namespace std;

int main(int argc, char const *argv[])
{
	
	float f = 4.5;
	int a = f; //C-style

	int b = static_cast<int>(f);
	cout << b << endl;

	return 0;
}

编译输出：

在这里插入图片描述
现在让我们对代码做一些修改:

#include <iostream>

using namespace std;

int main(int argc, char const *argv[])
{
	
	int a = 10;
	char c = 'a';

	
	int* q = (int*) &c;
	int *p = static_cast<int *>(&c);//编译错误，static_cast 不能将字符转换成指针

	return 0;
}

编译：
在这里插入图片描述

这意味着，即使您认为可以将特定对象类型转换为另一个对象，但这是非法的，static_cast也不允许这样做。

static_cast 用于基本数据类型之间的转换，如把int转换成char，把int转换成float。在c++ primer 中说道：c++ 的任何的隐式转换都是使用 static_cast 来实现。

让我们以继承为例，来看看这个例子：


#include <iostream>
using namespace std;

class Base { 

}; 
class Derived : public Base { 

}; 

int main(int argc, char const *argv[])
{
	
    Derived d1; 
    Base* b1 = (Base*)(&d1); // 允许 
    Base* b2 = static_cast<Base*>(&d1); 

	return 0;
}

编译：
在这里插入图片描述编译，上面的代码将不会出现任何错误。
1、我们取&d1，显式的存入Base中，存储在b1中。
2、我们取&d1，用static_cast将其转换成Base，存储在b2中。

我们知道static_cast执行严格的类型检查，让我们稍微修改一下代码看看，把继承改为private。


#include <iostream>
using namespace std;

class Base { 

}; 
class Derived :  private Base { 

}; 

int main(int argc, char const *argv[])
{
	
    Derived d1; 
    Base* b1 = (Base*)(&d1); // 允许 
    Base* b2 = static_cast<Base*>(&d1); 

	return 0;
}

编译：
在这里插入图片描述即使继承为受保护的，上面的代码也不会编译。因此，要使用static_cast，请将其继承为public。

使用static_cast将“向空指针”和“从空指针”进行强制转换。例子：


#include <iostream>
using namespace std;

int main(int argc, char const *argv[])
{
	
    int i = 10; 
    void* v = static_cast<void*>(&i); 
    int* ip = static_cast<int*>(v); 

	return 0;
}

编译：
在这里插入图片描述
const_cast

用于删除 const、volatile 和 __unaligned 特性（如将 const int 类型转换为 int 类型 ）

const_cast可用于更改const成员函数内的非const类成员。考虑以下代码片段。

#include <iostream>
using namespace std;

class student 
{ 
private: 
    int roll; 
public: 
    // 构造函数
    student(int r):roll(r) {} 
  
    // 在const_cast的帮助下改变roll的const函数
    void fun() const
    { 
        ( const_cast <student*> (this) )->roll = 5; 
    } 
  
    int getRoll()  { return roll; } 
}; 

int main(int argc, char const *argv[])
{
	
    student s(3); 
    cout << "Old roll number: " << s.getRoll() << endl; 
  
    s.fun(); 
  
    cout << "New roll number: " << s.getRoll() << endl; 
  
	return 0;
}

编译输出：
在这里插入图片描述

在const成员函数fun()中，编译器将“ this”视为“ const student * const this”，即“ this”是指向常量对象的常量指针，因此编译器不允许通过以下方式更改数据成员“这个”指针。const_cast将“ this”指针的类型更改为“ student * const this”。

const_cast可用于将const数据传递给不接收const的函数。例如：


#include <iostream>
using namespace std;


int fun(int* ptr) 
{ 
    return (*ptr + 10); 
} 
int main(int argc, char const *argv[])
{
	
    const int val = 10; 
    const int *ptr = &val; 
    int *ptr1 = const_cast <int *>(ptr); 
    cout << fun(ptr1)<<endl; 


	return 0;
}

编译输出：
在这里插入图片描述
const_cast比简单类型转换更安全。从某种意义上讲，如果强制类型与原始对象不相同，则强制强制转换不会发生，这是比较安全的。例如：

#include <iostream>
using namespace std;

int main(int argc, char const *argv[])
{
	
    int a1 = 40; 
    const int* b1 = &a1; 
    char* c1 = const_cast <char *> (b1); // 编译程序时出错
    *c1 = 'A'; 

	return 0;
}

编译：
在这里插入图片描述
程序编译失败，因为将“ int *”类型转换为“ char *”

const_cast也可以用来抛弃volatile属性。例如：


#include <iostream>
#include <typeinfo>  // typeid
using namespace std;

int main(int argc, char const *argv[])
{
	
    int a1 = 40; 
    const volatile int* b1 = &a1; 
    cout << "typeid of b1 " << typeid(b1).name() << '\n'; 
    int* c1 = const_cast <int *> (b1); 
    cout << "typeid of c1 " << typeid(c1).name() << '\n'; 

	return 0;
}

编译输出：
在这里插入图片描述在程序中，b1的typeid是PVKi（指向易失性和整数的指针），而c1的typeid是Pi（指向整数的指针）。

reinterpret_cast

reinterpret_cast是C ++中使用的一种强制转换运算符。

它用于转换任何类型的另一个指针的一个指针，而不管该类是否相互关联。
它不检查指针类型和指针所指向的数据是否相同。

用法如下：

reinterpret_cast <数据类型*>（指针变量）;

来看看 reinterpret_cast 简单用法：


#include <iostream>
using namespace std;

int main(int argc, char const *argv[])
{
	
    int* p = new int(65); 
    char* ch = reinterpret_cast<char*>(p); 
    cout << *p << endl; 
    cout << *ch << endl; 
    cout << p << endl; 
    cout << ch << endl; 

	return 0;
}

在这里插入图片描述
使用reinterpret_cast的目的：

1、reinterpret_cast是一种非常特殊且危险的类型转换操作符。并且建议使用适当的数据类型使用它，即（指针数据类型应与原始数据类型相同）。

2、它可以将任何指针类型转换为任何其他数据类型。

3、当我们要使用位时使用它。

4、它仅用于将任何指针转换为原始类型。

5、布尔值将转换为整数值，即0表示false，1表示true。

来看看下面一个例子：


#include <iostream>
using namespace std;


// 创建结构体mystruct
struct mystruct { 
    int x; 
    int y; 
    char c; 
    bool b; 
}; 



int main(int argc, char const *argv[])
{
	
    mystruct s; 
  
    // 结构体赋值
    s.x = 5; 
    s.y = 10; 
    s.c = 'a'; 
    s.b = true; 
  
    // 在强制转换期间，数据类型必须与原始数据类型相同
  
    // 将's'指针转换为'p'中int类型的指针。
    
    int* p = reinterpret_cast<int*>(&s); 
  
    cout << sizeof(s) << endl; 
  
    // 打印当前由*p指向的值
    cout << *p << endl; 
  
    // 将指针增加1
    p++; 
  
    // 打印下一个整数值
    cout << *p << endl; 
  
    p++; 
  
    // 用char *ch将char *指向p。
    // 
    char* ch = reinterpret_cast<char*>(p); 
  
    // 打印(*ch)指定的字符值
    cout << *ch << endl; 
  
    ch++;  
  
    bool* n = reinterpret_cast<bool*>(ch); 
    cout << *n << endl; 
  
    cout << *(reinterpret_cast<bool*>(ch)); 

	return 0;
}

编译输出：

在这里插入图片描述
再看一个例子：


#include <iostream>
using namespace std;

class A { 
public: 
    void fun_a() 
    { 
        cout << " In class A\n"; 
    } 
}; 
  
class B { 
public: 
    void fun_b() 
    { 
        cout << " In class B\n"; 
    } 
}; 


int main(int argc, char const *argv[])
{
	
    // 创建B类的对象
    B* x = new B(); 
  
    // 将指向B类引用的对象的指针转换为A类
    A* new_a = reinterpret_cast<A*>(x); 
  
    // 访问A类的函数。
    new_a->fun_a(); 
    return 0; 
}

编译输出：

在这里插入图片描述
dynamic_cast

dynamic_cast的转换格式：

dynamic_cast <type-id> (expression)

将expression转换为type-id类型，type-id必须是类的指针、类的引用或者是void *；如果type-id是指针类型，那么expression也必须是一个指针；如果type-id是一个引用，那么expression也必须是一个引用。

最简单的上行转换，比如Derived 继承自Basic，Derived 转换为Basic，进行上行转换时，是安全的，如下：

#include <iostream>
using namespace std;
 
class Basic{
     public:
          virtual int test(){return 0;}  // 必须为多态以使用运行时检查的 dynamic_cast
};
 
class Derived : public Basic{

     public:
          int test(){return 1;}
};
 
int main(int argc, char const *argv[]){
     Basic      cBasic;
     Derived    cDerived;
     
     Basic * pB1 = new Basic;
     Basic * pB2 = new Derived;
 
     //动态强制转换失败，因此pD1为空。
     Derived * pD1 = dynamic_cast<Derived * > (pB1);   
                 
 
     //动态强制转换成功，因此rD2引用派生对象。
     Derived & rD2 = dynamic_cast<Derived &> (*pB2);   
 
     return 0;
}

编译：

在这里插入图片描述
参考：static_cast in C++ | Type Casting operators
reinterpret_cast in C++ | Type Casting operators
const_cast in C++ | Type Casting operators
在这里插入图片描述
（微信公众号【程序猿编码】）

在这里插入图片描述
（添加本人微信号，备注加群，进入程序猿编码交流群，领取学习资料，获取每日干货）

微信公众号【程序猿编码】，这里Linux c/c++ 、Python、Go语言、数据结构与算法、网络编程相关知识，常用的程序员工具。还有汇聚精炼每日时政、民生、文化、娱乐新闻简报，即刻知晓天下事!

程序猿编码
关注
专栏目录
C++强制类型转换
FirMoonLight的博客
03-14 4482
C++提供了四种类型转换方法，分别为 static_cast<类型说明符>(表达式） dynamic_cast<类型说明符>(表达式） const_cast<类型说明符>(表达式） reinterpret_cast<类型说明符>(表达式） 按照适用范围从窄到宽的顺序介绍，先从使用频率比较低的reinterpret_cast开始，然后依次是const_cast，dynamic_cast，最后介绍static_cast。 reinterpret_cast in
C++ 重载强制类型转换运算符
weixin_45743799的博客
03-16 983
C++ 中，类型的名字（包括类的名字）本身也是一种运算符，即类型强制转换运算符。 类型强制转换运算符是单目运算符，也可以被重载，但只能重载为成员函数，不能重载为全局函数。经过适当重载后，(类型名)对象这个对对象进行强制类型转换的表达式就等价于对象.operator 类型名()，即变成对运算符函数的调用。 对 double 类型强制转换运算符进行了重载。 #include <iostream&...
C++的常见四种强制转换运算符
最新发布
weixin_51772979的博客
07-05 263
1、static_cast 是最常用的类型转换运算符，用于无风险的转换，如整数到浮点数，字符到整数等。 在编译时执行，不执行运行时类型检查（RTTI）。 示例：int x = static_cast(y);其中y可能是float类型。 2、dynamic_cast 专门用于处理对象的多态性，只能用于指针和引用，且涉及对象类必须有虚函数。 它在运行时检查类型的安全性，如果转换失败，对于指针类型返回 nullptr，对于引用类型抛出异常。 示例：Derived *dp = dynamic_cast<
C++ 强制类型转换运算符
weixin_45743799的博客
03-16 329
C++ 将类型名作为强制类型转换运算符。 C++ 引入了四种功能不同的强制类型转换运算符以进行强制类型转换：static_cast、reinterpret_cast、const_cast 和 dynamic_cast。 强制类型转换是有一定风险的，有的转换并不一定安全，如把整型数值转换成指针，把基类指针转换成派生类指针，把一种函数指针转换成另一种函数指针，把常量指针转换成非常量指针等。C++ 引入...
C++强制类型转换运算符|类型转换
qq_39451510的博客
08-23 316
强制类型转换运算符 1. const_cast 用于删除 const、volatile 和 __unaligned 特性（如将 const int 类型转换为 int 类型 ） #include <iostream> using namespace std; class CCTest { private: int m_number; public: void Number(int num) { m_number = num; } void prin
C++ 强制转换运算符
超级大洋葱的博客
02-21 237
大多数的 C++ 编译器都支持大部分通用的强制转换运算符： (type) expression 其中，type 是转换后的数据类型。下面列出了 C++ 支持的其他几种强制转换运算符： const_cast<type> (expr):</type> const_cast 运算符用于修改类型的 const / volatile 属性。除了 const 或 volatile 属性之外，目标类型必须与源类型相同。这种类型的转换主要是用来操作所传对象的 const 属性，可以加上 con
C++中四种强制类型转换的区别
12-22
使用标准C++的类型转换符：static_cast、dynamic_cast、reinterpret_cast和const_cast。 　1、static_cast 　用法：static_cast (expression) 　该运算符把expression转换为type-id类型，但没有运行时类型检查来...
深入解析C++中的动态类型转换与静态类型转换运算符
01-21
dynamic_cast 运算符 将操作数 expression ...有关静态和动态强制转换之间区别的描述，以及各在什么情况下适合使用，请参见 static_cast。 在托管代码中的 dynamic_cast的行为中有两个重大更改。 为指针的dynamic_ca
C++类型转换运算符的重载,自增自减运算符的重载
wo_ai_luo_的博客
11-09 1456
​ C++里面各种各样的运算符都可以拿来重载,虽然不是所有的运算符都可以重载,但是绝大部分都是可以重载的,比方说这个类型转换运算符的重载,自增自减运算符的重载.
c++ 四种强制类型转换介绍
TABE_的博客
05-13 361
c++ 四种强制类型转换介绍 const_cast , static_cast , dynamic_cast , reinterpret_cast 1. C风格的强制转换2.1 const_cast2.2 static_cast2.3 dynamic_cast2.4 reinterpret_cast C风格的强制转换(Type Cast)容易理解,不管什么类型的转换都可以使用使用下面的方式. TypeName b = (TypeName)a; 当然,C++也是支持C风格的强制转换,但是C风格的强制转换可能
c++强制转换运算符
qq_34460386的博客
11-21 332
强制转换运算符是一种特殊的运算符，它把一种数据类型转换为另一种数据类型 强制转换运算符是一元运算符，它的优先级也与其他一元运算符相同 大多数的c++编译器都支持大部分通用的强制转换运算符： (type ) expression 其中type是转换后的数据类型，下面列出了c++支持的其他几种强制转换运算符 const_cast(expr) const_cast运算符用于修改类型的
C++强制转换运算符
六炅的专栏
08-23 361
1、const_cast 作用：从类中移除const、volatile和_unaligned特性 声明语法：const_cast <type_id> (expression)下面看一段示例代码，就能明白这个关键字的作用是声明了// expre_const_cast_Operator.cpp // compile with: /EHsc #include <iostream>using names
c语言中强制类型转换运算符,C++四种强制类型转换运算符
weixin_39897758的博客
05-22 1043
C++有四种强制类型转换符，分别是dynamic_cast，const_cast，static_cast，reinterpret_cast。其中dynamic_cast与运行时类型转换密切相关，在这里我们先介绍dynamic_cast，其他三种在后面介绍。1、dynamic_cast运算符该转换符用于将一个指向派生类的基类指针或引用转换为派生类的指针或引用。注意：dynamic_cast转换符只能...
C++ 强制类型转换
2201_75772333的博客
05-03 2293
需要注意的是，使用 const_cast 去掉常量性质并修改数据可能导致未定义的行为。：这种类型转换允许进行任何指针或整型的转换。它可以将任何类型的指针转换为任何其他类型的指针，也可以将任何类型的指针转换。它可以用于基本数据类型之间的转换，也可以用于指向父类和子类之间的指针或引用的转换。向下转换（基类转换为派生类）没有动态类型检查，是不安全的。reinterpret_cast要转换的类型必须是指针类型、引用或算术类型。④用于类层次结构中基类和派生类之间指针或引用的转换。③把空指针转换成目标类型的指针。
C++ 命名的强制类型转换与类型相关运算符
lovely_ke的博客
07-26 183
一、强制类型转换简介 一个命名的强制类型转换具有如下形式： cast-name<type>(expression) 其中，type是转换的目标类型expression是要转换的值，如果type是引用类型，结果是左值。 cast-name的种类有:static_cast, dynamic_cast, const_cast, reinterpret_cast. （1）static...
运算符和强制类型转换
dichijiang3134的博客
01-31 189
本文主要介绍一下C＃中的运算符和类型强制转换，主要内容包括1.C＃中的可用运算符2.处理引用类型和值类型时相等的含义3.基本数据类型之间的数据转换4.装箱和开箱技术5.通过强制转换技术在引用类型之间转换6.运算符重载7.自定义类型强制转换下面详细介绍这7点内容一、C＃中的可用运算符C＃中的运算符跟c语言中的差不多，这里介绍几个特殊的运算符1.1 check和uncheck运算符...
C++之强制类型转换
专注
04-13 1811
C++中的强制类型转换是一种将一个数据类型转换为另一个数据类型的操作。在C++中，有四种类型的强制类型转换：静态转换、动态转换、常量转换和重新解释转换。（1）静态转换（static_cast）：静态转换是最常用的一种类型转换，它可以在不同但相关的类型之间进行转换，如基本数据类型之间的转换、父类指针向子类指针的转换等。但是需要注意的是，静态转换没有运行时类型检查，因此在进行转换时需要确保类型之间是相关的，否则可能会导致错误。
请详细解释c++强制类型转换运算符重载
05-17
在C++中，我们可以使用强制类型转换运算符来将一个数据类型转换为另一个数据类型，这在某些情况下是非常有用的。然而，有时候我们需要对自定义数据类型进行强制类型转换，这就需要使用运算符重载来实现。 强制类型转换运算符重载是指重载类中的强制类型转换运算符，它的语法如下： ```cpp operator type() { // 转换逻辑 } ``` 其中，`type`是你想要将类转换成的类型。注意，这里没有任何参数。 下面是一个示例，展示了如何重载强制类型转换运算符： ```cpp class MyInt { private: int n; public: MyInt(int n = 0) : n(n) {} operator double() { return static_cast<double>(n); } }; int main() { MyInt a(5); double b = static_cast<double>(a); std::cout << b << std::endl; return 0; } ``` 在这个示例中，我们定义了一个名为`MyInt`的类，并在其中实现了强制类型转换运算符重载。我们将`MyInt`类转换为`double`类型。在`main()`函数中，我们创建了一个`MyInt`对象，并使用`static_cast`将其强制转换为`double`类型。最后，我们输出了转换后的值。 需要注意的是，在使用强制类型转换运算符重载时，一定要慎重。因为这可能会导致一些不可预测的结果。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值