C++强制类型转换对比测试

最新推荐文章于 2023-04-19 14:42:38 发布
最新推荐文章于 2023-04-19 14:42:38 发布
阅读量376 收藏
点赞数
分类专栏： C++ 文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_49406295/article/details/119703893
版权

C++强制类型转换对比测试

0、总结

1、static_cast(object)
相当于传统的C语言里的强制转换，能转换非指针类型类和变量
2、dynamic_cast(object)
只能转换具有父子关系的类指针，而且下行转换还不许包含多态(虚函数)
条件比较苛刻，执行效率不高
3、reinterpret_cast(object)
强制转换一切类型指针，无任何检查，正确性由程序员自己负责

1、普通类型转换测试

指针和整数之间转换、指针之间转换(void*除外)只能用reinterpret_cast
整数之间转换可以只能用static_cast

void testGeneralType(void) //普通类型转换
{
    int a = 0;
    char b = 2;
    int* p = nullptr;
    char* cp = nullptr;
    void* vp = nullptr;

    std::cout << "\n####1、普通类型转换测试####\n";

    //1、char -> int
    a = static_cast<int>(b);        //ok
    //a = dynamic_cast<int>(b);     //error,类型<type>必须是指向完整类类型或 void * 的指针或引用
    //a = reinterpret_cast<int>(b); //error,不能转换普通类型

    //2、int -> int*
    //p = static_cast<int*>(a);     //error,无效类型转换
    //p = dynamic_cast<int*>(a);    //error,类型<type>必须是指向完整类类型或 void * 的指针或引用
    p = reinterpret_cast<int*>(a);  //ok

    //3、int* -> int
    //a = static_cast<int>(p);     //error,无效类型转换
    //a = dynamic_cast<int>(p);    //error,类型<type>必须是指向完整类类型或 void * 的指针或引用
    a = reinterpret_cast<int>(p);  //ok

    //4、char* -> int*
    //p = static_cast<int*>(cp);    //error,无效类型转换
    //p = dynamic_cast<int*>(cp);   //error,类型<type>必须是指向完整类类型或 void * 的指针或引用
    p = reinterpret_cast<int*>(cp); //ok

    //5、void* -> int*
    p = static_cast<int*>(vp);      //ok
    //p = dynamic_cast<int*>(vp);   //error,类型<type>必须是指向完整类类型或 void * 的指针或引用
    p = reinterpret_cast<int*>(vp); //ok

    //6、int* -> void*
    vp = static_cast<void*>(p);      //ok
    //vp = dynamic_cast<void*>(p);   //error,操作数(object)必须是指向完整类类型的指针
    vp = reinterpret_cast<void*>(p); //ok
}

2、类转换测试

只能用static_cast，但无法进行下行转换

void testClass(void) //类转换
{
    A a;
    B b;
    Father f;
    Son s;

    std::cout << "\n####2、类的转换测试####\n";

    //1、上行转换
    std::cout << "上行转换：";
    f = static_cast<Father>(s);        //ok
    f.fun();
    //f = dynamic_cast<Father>(s);     //error,类型<type>必须是指向完整类类型或 void * 的指针或引用
    //f = reinterpret_cast<Father>(s); //error

    //2、下行转换
    //s = static_cast<Son>(f);      //error,不存在转换规则
    //s = dynamic_cast<Son>(f);     //error,类型<type>必须是指向完整类类型或 void * 的指针或引用
    //s = reinterpret_cast<Son>(f); //error,不允许

    //3、不相关类型转换
    std::cout << "不相关类转换：";
    a = static_cast<A>(a);        //ok
    a.fun();
    //a = dynamic_cast<A>(a);     //error,类型<type>必须是指向完整类类型或 void * 的指针或引用
    //a = reinterpret_cast<A>(a); //error,不允许
}

3、类的指针转换测试

reinterpret_cast可以任意转换
static_cast和dynamic_cast只能转换具有父子关系的类型指针
其中dynamic_cast进行下行转换时必须包含多态(虚函数)

void testClassPointer(void) //类的指针转换
{
    A* a = new A; //A和B是两个毫无关联的类
    B* b = new B;
    Father* f = new Father; //父类
    Son* s = new Son;       //子类

    std::cout << "\n####3、类的指针转换测试####\n";

    //1、上行指针转换
    std::cout << "上行转换：\n";
    Father* f1 = static_cast<Father*>(s);  //Son -> Father
    Father* f2 = dynamic_cast<Father*>(s);
    Father* f3 = reinterpret_cast<Father*>(s);
    f1->fun(); //都能通过
    f2->fun();
    f3->fun();

    //2、下行指针转换
    std::cout << "下行转换：\n";
    Son* s1 = static_cast<Son*>(f);      //可以不包含多态
    Son* s2 = dynamic_cast<Son*>(f);     //下行转换必须包含多态，否则编译报错
    Son* s3 = reinterpret_cast<Son*>(f); //Father -> Son
    s1->fun(); //包含多态时都能通过
    s2->fun();
    s3->fun();

    //3、不相关的类型转换
    std::cout << "不相关类转换：\n";
    
    //A* a1 = static_cast<A*>(b);    //error,无效类型转换
    //A* a2 = dynamic_cast<A*>(b);   //error,必须包含多态
    A* a3 = reinterpret_cast<A*>(b); //完全强制类型转换，可转换两个毫无关系的类
    a3->fun();
}

4、类的引用转换测试

都可以转换，但dynamic_cast进行下行转换时会抛出异常

void testClassReference(void) //引用类型转换
{
    A a;
    A& ra = a; //A的引用
    B b;
    B& rb = b; //B的引用
    Father f;
    Father& rf = f; //Father的引用
    Son s;
    Son& rs = s;    //Son的引用

    std::cout << "\n####4、类的引用转换测试####\n";

    //1、上行转换
    std::cout << "上行转换\n";
    rf = static_cast<Father&>(rs);      //ok
    rf.fun();
    rf = dynamic_cast<Father&>(rs);     //ok
    rf.fun();
    rf = reinterpret_cast<Father&>(rs); //ok
    rf.fun();

    //2、下行转换
    std::cout << "下行转换\n";
    rs = static_cast<Son&>(rf);      //ok
    rs.fun();
    rs = dynamic_cast<Son&>(rf);     //ok,会抛出异常，但能转换成功！！！
    rs.fun();
    rs = reinterpret_cast<Son&>(rf); //ok
    rs.fun();

    //3、不相关类型转换
    std::cout << "不相关类转换\n";
    ra = static_cast<A&>(ra);      //ok
    ra.fun();
    ra = dynamic_cast<A&>(ra);     //ok
    ra.fun();
    ra = reinterpret_cast<A&>(ra); //ok
    ra.fun();
}

完整测试代码

test.h

#ifndef __TEST_H
#define __TEST_H

#include <iostream>
#include <functional>
//#define NO_VIRTUAL
using namespace std;

class A
{
public:
    void fun()
    {
        std::cout << "fun A" << "\n";
    }
};

class B
{
public:
    void fun()
    {
        std::cout << "fun B" << "\n";
    }
};

class Father //父类
{
public:
    void fun()
    {
        std::cout << "fun Father\n";
    }

#ifndef NO_VIRTUAL
    virtual void test()
    {
        std::cout << "Father virtual test\n";
    }
#endif
};

class Son : public Father //子类
{
public:
    void fun()
    {
        std::cout << "fun Son\n";
    }

#ifndef NO_VIRTUAL
    void test() override //重写父类方法
    {
        std::cout << "Son virtual test\n";
    }
#endif
};

#endif

test.cpp

#include "test.h"

void testGeneralType(void) //普通类型转换
{
    int a = 0;
    char b = 2;
    int* p = nullptr;
    char* cp = nullptr;
    void* vp = nullptr;

    std::cout << "\n####1、普通类型转换测试####\n";

    //1、char -> int
    a = static_cast<int>(b);        //ok
    //a = dynamic_cast<int>(b);     //error,类型<type>必须是指向完整类类型或 void * 的指针或引用
    //a = reinterpret_cast<int>(b); //error,不能转换普通类型

    //2、int -> int*
    //p = static_cast<int*>(a);     //error,无效类型转换
    //p = dynamic_cast<int*>(a);    //error,类型<type>必须是指向完整类类型或 void * 的指针或引用
    p = reinterpret_cast<int*>(a);  //ok

    //3、int* -> int
    //a = static_cast<int>(p);     //error,无效类型转换
    //a = dynamic_cast<int>(p);    //error,类型<type>必须是指向完整类类型或 void * 的指针或引用
    a = reinterpret_cast<int>(p);  //ok

    //4、char* -> int*
    //p = static_cast<int*>(cp);    //error,无效类型转换
    //p = dynamic_cast<int*>(cp);   //error,类型<type>必须是指向完整类类型或 void * 的指针或引用
    p = reinterpret_cast<int*>(cp); //ok

    //5、void* -> int*
    p = static_cast<int*>(vp);      //ok
    //p = dynamic_cast<int*>(vp);   //error,类型<type>必须是指向完整类类型或 void * 的指针或引用
    p = reinterpret_cast<int*>(vp); //ok

    //6、int* -> void*
    vp = static_cast<void*>(p);      //ok
    //vp = dynamic_cast<void*>(p);   //error,操作数(object)必须是指向完整类类型的指针
    vp = reinterpret_cast<void*>(p); //ok
}

void testClass(void) //类转换
{
    A a;
    B b;
    Father f;
    Son s;

    std::cout << "\n####2、类的转换测试####\n";

    //1、上行转换
    std::cout << "上行转换：";
    f = static_cast<Father>(s);        //ok
    f.fun();
    //f = dynamic_cast<Father>(s);     //error,类型<type>必须是指向完整类类型或 void * 的指针或引用
    //f = reinterpret_cast<Father>(s); //error

    //2、下行转换
    //s = static_cast<Son>(f);      //error,不存在转换规则
    //s = dynamic_cast<Son>(f);     //error,类型<type>必须是指向完整类类型或 void * 的指针或引用
    //s = reinterpret_cast<Son>(f); //error,不允许

    //3、不相关类型转换
    std::cout << "不相关类转换：";
    a = static_cast<A>(a);        //ok
    a.fun();
    //a = dynamic_cast<A>(a);     //error,类型<type>必须是指向完整类类型或 void * 的指针或引用
    //a = reinterpret_cast<A>(a); //error,不允许
}

void testClassPointer(void) //类的指针转换
{
    A* a = new A; //A和B是两个毫无关联的类
    B* b = new B;
    Father* f = new Father; //父类
    Son* s = new Son;       //子类

    std::cout << "\n####3、类的指针转换测试####\n";

    //1、上行指针转换
    std::cout << "上行转换：\n";
    Father* f1 = static_cast<Father*>(s);  //Son -> Father
    Father* f2 = dynamic_cast<Father*>(s);
    Father* f3 = reinterpret_cast<Father*>(s);
    f1->fun(); //都能通过
    f2->fun();
    f3->fun();

    //2、下行指针转换
    std::cout << "下行转换：\n";
    Son* s1 = static_cast<Son*>(f);      //可以不包含多态
    Son* s2 = dynamic_cast<Son*>(f);     //下行转换必须包含多态，否则编译报错
    Son* s3 = reinterpret_cast<Son*>(f); //Father -> Son
    s1->fun(); //包含多态时都能通过
    s2->fun();
    s3->fun();

    //3、不相关的类型转换
    std::cout << "不相关类转换：\n";
    
    //A* a1 = static_cast<A*>(b);    //error,无效类型转换
    //A* a2 = dynamic_cast<A*>(b);   //error,必须包含多态
    A* a3 = reinterpret_cast<A*>(b); //完全强制类型转换，可转换两个毫无关系的类
    a3->fun();
}

void testClassReference(void) //引用类型转换
{
    A a;
    A& ra = a; //A的引用
    B b;
    B& rb = b; //B的引用
    Father f;
    Father& rf = f; //Father的引用
    Son s;
    Son& rs = s;    //Son的引用

    std::cout << "\n####4、类的引用转换测试####\n";

    //1、上行转换
    std::cout << "上行转换\n";
    rf = static_cast<Father&>(rs);      //ok
    rf.fun();
    rf = dynamic_cast<Father&>(rs);     //ok
    rf.fun();
    rf = reinterpret_cast<Father&>(rs); //ok
    rf.fun();

    //2、下行转换
    std::cout << "下行转换\n";
    rs = static_cast<Son&>(rf);      //ok
    rs.fun();
    rs = dynamic_cast<Son&>(rf);     //ok,会抛出异常，但能转换成功！！！
    rs.fun();
    rs = reinterpret_cast<Son&>(rf); //ok
    rs.fun();

    //3、不相关类型转换
    std::cout << "不相关类转换\n";
    ra = static_cast<A&>(ra);      //ok
    ra.fun();
    ra = dynamic_cast<A&>(ra);     //ok
    ra.fun();
    ra = reinterpret_cast<A&>(ra); //ok
    ra.fun();
}

int main()
{
    //C++强制类型转换对比测试
    //运行环境 VS2019
    testGeneralType();    //通用类型转换测试
    testClass();          //类转换测试
    testClassPointer();   //类指针转换测试
    testClassReference(); //类的引用转换测试

    /* 总结：
    * 1、普通类型转换
    *   指针和整数之间转换、指针之间转换(void*除外)只能用reinterpret_cast
    *   整数之间转换可以只能用static_cast
    * 2、类之间转换
    *   只能用static_cast，但无法进行下行转换
    * 3、类的指针转换
    *   reinterpret_cast可以任意转换
    *   static_cast和dynamic_cast只能转换具有父子关系的类型指针
    *   其中dynamic_cast进行下行转换时必须包含多态(虚函数)
    * 4、类的引用转换
    *   都可以任意转换
    */

    /* 特性
    * 1、static_cast<type>(object)
    *   相当于传统的C语言里的强制转换，能转换非指针类型类和变量
    * 2、dynamic_cast<type>(object)
    *   只能转换具有父子关系的类指针，而且下行转换还不许包含多态(虚函数)
    *   条件比较苛刻，执行效率不高
    * 3、reinterpret_cast<type>(object)
    *   强制转换一切类型指针，无任何检查，正确性由程序员自己负责
    */

    return 0;
}
蒋钊锋
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C 强制类型转换
化茧成蝶007
08-21 318
C 强制类型转换 强制类型转换是把变量从一种类型转换为另一种数据类型。例如，如果您想存储一个 long 类型的值到一个简单的整型中，您需要把 long 类型强制转换为 int 类型。您可以使用强制类型转换运算符来把值显式地从一种类型转换为另一种类型，如下所示： (type_name) expression 请看下面的实例，使用强制类型转换运算符把一个整数变量除以另一个整数变量，得到
解析C++中四种强制类型转换的区别详解
09-05
C++中的四种强制类型转换是static_cast、dynamic_cast、const_cast和reinterpret_cast，它们提供了对类型转换的不同控制和用途，确保了代码的清晰性和安全性。下面分别详细解释这四种转换。 1. static_cast：主要...
C++四种强制类型转换
12-22
四种强制类型转换:static_cast    const_cast    dynamic_cast     reinterpret_cast 　　1、static_cast 　　编译器隐式执行的任何类型转换都可以由static_cast显示完成。 　　①用于类层次结构中基类和子类之间指针或引用的转换。 进行上行转换（把子类的指针或引用转换成基类表示）是安全的； 进行下行转换（把基类指针或引用转换成子类表示）时，由于没有动态类型检查，所以是不安全的。 ②用于基本数据类型之间的转换，如把int转换成char，把int转换成enum。这种转换的安全性也要开发人员来保证。 ③把空指针转换成目标
C++中的类型转换测试程序
tianyingang的博客
04-28 129
template< typename T> std::string quireTypeName(T value){ std::string type; if(typeid(value).name() == typeid(bool).name()) type = "bool"; else if(typeid(value).name() == typeid(un...
测试类型转换
Healer_小振的博客
08-04 167
public class day005 { public static void main (String[] args) { //小转大/隐式转换 byte m = 10; long n = m;//小转大，右面的m是小类型，给左面的n大类型赋值，可以直接使用 //大转小/显式转换 float x = 9.9F; int y =(int)x;//大转小，右面的x是大类型给右面的小类型...
Java—测试自动类型转换
老窦的博客
01-21 181
/** 测试自动类型转换（容量小的数据类型可以自动转换为容量大的数据类型） @author 老窦 */ public class TestTypeConvert { public static void main(String[] args) { int a = 324; long b = a; double d = b; // a=b; // long e = 3.23F...
C++中强制类型转换的应用
12-22
1.1 强制类型转换 　大家都知道在C语言里强制类型转换的方法非常简单，只要在要转换的变量... 　在C++语言里为了让强制类型转换更明显，更安全，所以把不同情况下的强制类型转换分为四种，分别为： 　static_cast 
基于c++强制类型转换的(总结)详解
09-05
本文将深入探讨C++中的四种强制类型转换：`static_cast`，`dynamic_cast`，`const_cast`，以及`reinterpret_cast`。 首先，让我们了解什么是类型转换。类型转换允许程序员在不同数据类型之间进行转换，以适应特定的...
深入C++四种强制类型转换的总结
01-20
c++中提供了四种新的强制转换分别是：const_cast、dynamic_cast、reinterpret_cast、static_cast.这四种转换类型，每一种都适用于特定的目的：const_cast 一般用于强制取消对象的常量性。它是唯一能够做到这一点的...
C++中四种强制类型转换的区别
12-22
使用标准C++的类型转换符：static_cast、dynamic_cast、reinterpret_cast和const_cast。 　1、static_cast 　用法：static_cast (expression) 　该运算符把expression转换为type-id类型，但没有运行时类型检查来...
【C\C++】C++四种强制转换原理与价值
最新发布
Michael
04-19 1820
适用范围：static_cast 可以进行常规的类型转换，例如将 int 类型转换为 double 类型，也可以进行具有继承关系的指针或引用之间的转换，例如将派生类指针或引用转换为基类指针或引用，而隐式转换只适用于一些特定的场景，例如将 int 类型赋值给 double 类型时，会自动进行类型转换。在实际编程中，应该根据具体的场景选择合适的强制转换方式。提高程序的性能：强制转换可以提高程序的性能，例如在进行指针或引用之间的转换时，可以避免数据的复制和额外的内存占用，提高程序的效率。
数组强制类型转换的效率问题
rqX的博客
05-06 408
数组强制类型转换的效率问题 数组向下或向上强制类型转换的方式： uint8_t text[16]; uint32_t text32[4]; uint8_t *pt = (uint8_t *)text32; uint32_t *pt2 = (uint32_t *)text; for (int i = 0;i < 4; ++i) pt[i] = sbox[pt[i]]; 以上相比较下面的方式具有明显的效率降低，采用下面的方式能获得可观的效率收益： uint8_t b[4]; b[0] = (ui
C#转整型的三种方式的区别以及效率对比
汤圆一碗的博客
11-30 1761
C#转整型的三种方式的区别 三种转换方式： 1. 强制转换（int） 2. Convert.ToInt32() 3. int.Parse(string) 或 int.TryParse(string, out int) 三种类型转整型： a.浮点型转整型 由报错的提示可知int.Parse() 或 int.TryParse(string, out int)这两种方法只能将字符串数字转为整型，不能...
C语言知识点汇总之一（全）
wuwuku123的博客
09-17 5512
1、scanf() scanf()函数解析：由scanf说起之1：scanf函数和回车、空格 及其返回值 视频见：小甲鱼，VIP资料\【视频教程】C++快速入门\第二讲和第三讲 要求：编写一个程序，要求用户输入一串整数和任意数目的空格，这些整数必须位于同一行中，但允许出现在该行中的任何位置。当用户按下键盘上的“Enter”键时，数据输入结束。程序自动对所有的整数进行求和并打印出结果。 示例代码： #define _CRT_SECURE_NO_WARNINGS #include &lt...
C++新特性09_强制转换reinterpret_cast(等价于C中的显式强转；增加了代码的可读性；用于进行各种不同类型的转换；编译期处理,执行的是逐字节复制的操作，运行期不进行检查；一般不使用)
分享学习成长历程，Winter is coming！
11-16 2534
reinterpret_cast等价于C中的显式强转 1. 显式强转 int n = 1; //显式强转 int* p = (int*)n; 2. reinterpret_cast （1）用于进行各种不同类型的转换 不同类型指针之间；不同类型引用之间；指针和能容纳指针的整数类型之间的转换 （2）编译期处理,执行的是逐字节复制的操作 （3）类似于显式强转，后果自负 3.学习视频地址：强制转换reinterpret_cast 4.学习笔记：强制转换reinterpret_cast笔记 #includ
C++四种类型强制转换——const_cast、static_cast、dynamic_cast、reinterpret_cast
热门推荐
yi_chengyu的博客
12-14 1万+
文章目录一、const_cast1.基本知识2.示例演示二、static_cast1.基本知识2.示例演示三、dynamic_cast1.基本知识2.示例演示四、reinterpret_cast1.基本知识2.示例演示 一、const_cast 1.基本知识 (1)const_cast只针对指针、引用，当然，this指针也是其中之一。 (2)const_cast的大部分使用主要是将常量指针转换为常指针。常量指针指向的空间的内容不允许被修改，但是使用const_cast进行强制转换就可以修改。 (3)co.
C++中的强制类型转换
qq100440110的专栏
12-10 519
关于强制类型转换的问题，很多书都讨论过，写的最详细的是C++ 之父的《C++ 的设计和演化》。最好的解决方法就是不要使用C风格的强制类型转换，而是使用标准C++的类型转换符：static_cast, dynamic_cast。标准C++中有四个类型转换符：static_cast、dynamic_cast、reinterpret_cast、和const_cast。下面对它们一一进行介绍。
C++ reinterpret_cast,const_cast等 显式类型转换总结
飞奔的火鸟
04-09 115
reinterpret_cast,const_cast,static_cast,dynamic_cast 显式类型转换 [code="cpp"]#include int main(void) { //reinterpret_cast //将一个类型指针转换为另一个类型指针，这种在转换不修改指针变量值数据存放格式 //只需在编译时重新解释指针的类型，他可以将指针转化为一个整型...
不允许指针指向不完整的类类型 问题
fistraiser的博客
10-24 1057
没有include需要的文件
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值