C/C++：类型转换

最新推荐文章于 2022-10-10 11:44:36 发布
最新推荐文章于 2022-10-10 11:44:36 发布
阅读量675 收藏 1
点赞数
分类专栏： C-C++ 文章标签： 类型转换 c-c++ C C++
本文为博主原创文章，未经博主允许不得转载。
本文链接：https://blog.csdn.net/test1280/article/details/72763451
版权

C++：dynamic_cast、static_cast

实验环境：

[test1280@localhost ~]$ uname -a
Linux localhost.localdomain 2.6.18-371.el5 #1 SMP Thu Sep 5 21:21:44 EDT 2013 x86_64 x86_64 x86_64 GNU/Linux
……
gcc 版本 4.1.2 20080704 (Red Hat 4.1.2-54)

C/C++中有两种类型转换：

一种是隐式的类型转换，例如下面三种情况：

1.赋值表达式，右值转换为待赋值变量的类型；
2.调用函数时，虚实结合，实参转变为形参的类型；
3.函数返回时，返回的值（或表达式的值）转换为函数声明的返回类型。

一种是显式的类型转换，分为C风格以及C++风格：

1.C风格：

(target_type)varable

#include <stdio.h>
#include <stdlib.h>

int main()
{
    double d = 1.23;
    int i = (int)d;
    return 0;
}

2.C++风格：

C++风格共有5种（1+4）：

target_type(varable)

#include <iostream>

using namespace std;

int main()
{
    double d = 1.23;
    int i = int(d);
    return 0;
}

其余四种为：dynamic_cast、static_cast、const_cast以及reinterpret_cast。

今天主要了解dynamic_cast以及static_cast。

upcast：向上转型，上行转型，指的是由一个子类对象转为父类对象的过程；
downcast：向下转型，下行转型，指的是由一个父类对象转为子类对象的过程。

一个子类对象转为其父类对象当然是安全的，因为子类对象拥有父类对象（继承）；反之则不尽然。

苹果是水果的子类：

一个苹果当然是一个水果，水果的属性苹果都有，但是一个水果却未必是一个苹果，也可能是一个香蕉，一个梨，等等。

static_cast

编译器在编译时进行类型检查，如果转换失败则编译错误。

成功：

#include <iostream>

using namespace std;

int main()
{
    double d = 1.23;
    int i = static_cast<int>(d);
    return 0;
}

失败：

#include <iostream>

using namespace std;

class Fruit{};

int main()
{
    Fruit fruit;
    int i = static_cast<int>(fruit);
    return 0;
}
g++ -o main main.C
main.C: In function ‘int main()’:
main.C:10: 错误：从类型 ‘Fruit’ 到类型 ‘int’ 中的 static_cast 无效

通常用于转换数值类型，进行非多态的类型转换。

static_cast< type-id >(expression)

将expression转换成类型type-id，type-id和expression必须是指针、引用、算术类型或枚举类型。

表达式static_cast< type-id >(expression)，expression的值转换为模板中指定的类型type-id。在运行时转换过程中，不进行类型检查来确保转换的安全性。

static_cast它能在内置的数据类型间互相转换，对于类只能在有联系的指针类型间进行转换。可以在继承体系中把指针转换来转换去，但是不能转换成继承体系外的一种类型。

#include <iostream>

using namespace std;

class Person
{
public:
    string name;
    int age;
    int male;
};

class Student:public Person
{
public:
    int classId;
    string major;
public:
    void display();
};

void Student::display()
{
    cout<<"name is :"<<name<<endl;
    cout<<"age is :"<<age<<endl;
    cout<<"male is :"<<male<<endl;
    cout<<"classId is :"<<classId<<endl;
    cout<<"major is :"<<major<<endl;
}

int main()
{
    Student *s = new Student;
    //向上转型成功，因为s指向的对象是Student类型，而其是Person的子类，在同一继承树中。
    Person *p = static_cast<Person *>(s);

    p = new Person;
    //向下转型成功，因为Person与Student在同一继承树中，但是是不安全的，因为p指向的是一个父类对象
    //将父类对象直接转为子类对象，调用子类特有的方法很可能出问题。
    s = static_cast<Student *>(p);
    s->display();

    return 0;
}
[test1280@localhost ~]$ !g
g++ -o main main.C
[test1280@localhost ~]$ ./main
name is :
age is :0
male is :0
classId is :0
段错误

上面的例子将一个父类对象转换为子类对象，因为他们在同一继承树中，所以转换没问题，编译时可以通过。

但是在运行时，发现转换后并没有major这样的子类特有的成员，调用子类方法（display）访问这个成员时就导致了段错误。

切记，static_cast是仅仅在编译期进行检查（转型失败时报编译错误），若向下转型可以直接编译过去，但可能在运行时错误。

dynamic_cast

dynamic_cast< type-id >(expression)

在运行期，会检查这个转换是否可能。

type-id与expression必须是一个指针或引用：

若expression是指针，那么type-id也应该是一个指针类型；
若expression是引用，那么type-id也应该是一个引用类型。

dynamic_cast仅能应用于指针或者引用，不支持内置数据类型。

当转换失败时，若type-id是一个指针，那么失败返回一个NULL，若type-id是一个引用，那么失败抛出异常。

它不仅仅像static_cast那样，检查转换前后的两个指针是否属于同一个继承树，它还要检查被指针引用的对象的实际类型，确定转换是否可行。

#include <iostream>

using namespace std;

class Person
{
public:
    Person(){};
    virtual ~Person(){};
    string name;
    int age;
    int male;
};

class Student:public Person
{
public:
    int classId;
    string major;
public:
    void display();
};

void Student::display()
{
    cout<<"name is :"<<name<<endl;
    cout<<"age is :"<<age<<endl;
    cout<<"male is :"<<male<<endl;
    cout<<"classId is :"<<classId<<endl;
    cout<<"major is :"<<major<<endl;
}

int main()
{
    Student *s = new Student;
    //向上转型成功，因为s指向的对象是Student类型，而其是Person的子类，在同一继承树中。
    //在向上转型时，dynamic_cast与static_cast一致。
    Person *p = dynamic_cast<Person *>(s);

    p = new Person;
    // 向下转型失败，这里将会返回一个空指针。
    // p实际指向的值一个父类对象，并不是Student对象，所以向下转型失败。
    s = dynamic_cast<Student *>(p);
    if (s == NULL)
    {
        cout<<"s is NULL"<<endl;
    }

    return 0;
}
[test1280@localhost ~]$ !g
g++ -o main main.C
[test1280@localhost ~]$ ./main
s is NULL

注意这里不仅仅修改了下面，还给上面的基类Person增加了一个virtual方法。

若基类没有virtual方法且使用dynamic_cast进行向下转型，则编译失败：

#include <iostream>

using namespace std;

class A
{
};

class B:public A
{
};

int main()
{
    A *pa = new A;
    B *pb = dynamic_cast<B *>(pa);
    return 0;
}
[test1280@localhost ~]$ !g
g++ -o main main.C
main.C: In function ‘int main()’:
main.C:16: 错误：无法将 ‘pa’ 从类型 ‘A*’ 动态转换到类型 ‘class B*’ (source type is not polymorphic)

这个时候我们给A增加一个virtual方法：

#include <iostream>

using namespace std;

class A
{
public:
    virtual void foo(){};
};

class B:public A
{
};

int main()
{
    A *pa = new A;
    B *pb = dynamic_cast<B *>(pa);
    return 0;
}

就可以编译过去啦。

dynamic_cast在帮助你浏览继承层次上是有限制的。它不能被用于缺乏虚函数的类型上。也即如果想将基类指针转换为派生类指针，如果基类不是虚类则无法实现。

这是由于运行时类型检查需要运行时类型信息，而这个信息存储在类的虚函数表中，只有定义了虚函数的类才有虚函数表，没有定义虚函数的类是没有虚函数表的。

dynamic_cast被用于安全地沿着类的继承关系向下进行类型转换。这就是说，你能用dynamic_cast把指向基类的指针或引用转换成指向其派生类或其兄弟类的指针或引用，而且你能知道转换是否成功。

若是向上转型则不要求基类包含virtual：

#include <iostream>

using namespace std;

class A
{
};

class B:public A
{
};

int main()
{
    B *pb = new B;
    A *pa = dynamic_cast<A *>(pb);
    return 0;
}

直接编译就可以过，向上转型不需要基类包含virtual函数。

再看一个dynamic_cast对引用失败的例子：

#include <iostream>

using namespace std;

class A
{
public:
    virtual void foo(){};
};

class B:public A
{
};

int main()
{
    A a;
    A &ra = a;
    B &rb = dynamic_cast<B &>(ra);
    return 0;
}
[test1280@localhost ~]$ !g
g++ -o main main.C
[test1280@localhost ~]$ ./main
terminate called after throwing an instance of 'std::bad_cast'
  what():  St8bad_cast
已放弃

bad_cast！！！

关于dynamic_cast还有一点需要注意，是在多重继承时upcast的问题。

有类关系图如下（好吧，其实我画的不标准）：

这里写图片描述

#include <iostream>

using namespace std;

class A
{
public:
    virtual void foo(){};
};

class B:public A
{
};

class C:public A
{
};

class D:public B, public C
{
};

int main()
{
    D *pd = new D;
    A *pa = dynamic_cast<A *>(pd);
    if (pa == NULL)
        cout<<"pa is NULL"<<endl;
    return 0;
}

[test1280@localhost ~]$ !g
g++ -o main main.C
main.C: In function ‘int main()’:
main.C:26: 错误：‘A’ 是 ‘D’ 的有歧义的基类

额，B和C都是A的子类，而D是继承自B/C，你说向上转型时它走D->B->A还是走D->C->A？

遇到这种情况要依次沿着类结构向上衍生：

#include <iostream>

using namespace std;

class A
{
public:
    virtual void foo(){};
};

class B:public A
{
};

class C:public A
{
};

class D:public B, public C
{
};

int main()
{
    D *pd = new D;
    B *pb = dynamic_cast<B *>(pd);
    A *pa = dynamic_cast<A *>(pb);
    if (pa == NULL)
        cout<<"pa is NULL"<<endl;
    return 0;
}

网上的Blog说遇到这样的upcast问题会导致转A为NULL，但我这里是直接编译器报错了，可能是编译器不同的行为吧~

参考自：

0.http://www.jellythink.com/archives/205
1.http://www.jianshu.com/p/a666132944ef
2.http://riddickbryant.iteye.com/blog/547361
3.http://www.cnblogs.com/5iedu/articles/5585895.html
4.http://blog.csdn.net/yfkiss/article/details/7277433
5.https://stackoverflow.com/questions/15114093/getting-source-type-is-not-polymorphic-when-trying-to-use-dynamic-cast

test1280
关注
专栏目录
C/C++学习路线总结与分享
dvlinker的技术专栏
10-07 8万+
C/C++学习路线总结与分享
C/C++类型转换的本质
qq_33287871的博客
09-06 758
在 C/C++ 中，不同的数据类型之间可以相互转换：无需用户指明如何转换的称为自动类型转换（隐式类型转换），需要用户显式地指明如何转换的称为强制类型转换（显式类型转换），这点已在《C++转换构造函数》中进行了说明。 隐式类型转换利用的是编译器内置的转换规则，或者用户自定义的转换构造函数以及类型转换函数（这些都可以认为是已知的转换规则），例如从 int 到 double、从派生类到基类、从type *到void *、从 double 到 Complex 等。 type *是一个具体类型的指针，例如int *、
一个c++转c的工具（cfront源码）
01-14
一个c++转c的工具（cfront源码），很好的工具源代码。满足特殊人使用。
【C/C++】类型转换
qq_53893431的博客
09-29 584
C++类型转换
C++：C++的类型转换
最新发布
zhang_si_hang的博客
10-10 3438
在C语言中，如果。1. 隐式类型转化：编译器在编译阶段自动进行，能转就转，不能转就编译失败2. 显式类型转化：需要用户自己处理C风格的转换格式很简单，但是有不少缺点的：1. 隐式类型转化有些情况下可能会出问题：比如数据精度丢失2. 显式类型转换将所有情况混合在一起，代码不够清晰因此C++提出了自己的类型转化风格，注意。
C到C++转换学习笔记
sansan的博客
10-03 1041
C到C++转换（一） 我是一个正在学习c++的同学，把自己的学习笔记和一些自己的理解记录下来。如果有什么地方写得不对，还希望各位朋友指正。 我写的是有c语言基础之后学习c++ 的学习经历。并不是零基础学习c++。 1.第一个c++程序 首先c++是包容所以c的规则，第一个不同的地方就是头文件。在c里面头文件都是以 .h 结尾，在c++里所有的c头文件都去掉 .h结尾并在前面加上c。例如：incl...
使用dynamic_cast报错source type is not polymorphic
QingTC
10-02 9589
#include  using namespace std;  class C{   public:   virtual ~C(){}////////////基类必须要加这个虚函数，不然就会报以下错误，  };  class A:public C{  };  class B:public C{  }; int main(){ C* pa=new A(); B* pb=dyn
C/C++ 和 Matlab 类型转换器：C/C++ 类型（STL、openCV）和 Matlab 矩阵（编译或运行时）之间的双向转换-matlab开发
05-30
-> Matlab 类型转换器简介：C/C++ 类型（本机、STL、openCV...）和 Matlab 矩阵（编译或运行时）之间的双向转换。 关键词：C、C++、mxArray、OpenCV、IplImage、迭代器、mex、引擎 描述： 考虑以下场景（尤其是在...
C/C++学习笔记：C 语言强制类型转换
C语言C++学习俱乐部：765860056
12-17 2099
强制类型转换是把变量从一种类型转换为另一种数据类型。例如，如果您想存储一个 long 类型的值到一个简单的整型中，您需要把 long 类型强制转换为 int 类型。 您可以使用强制类型转换运算符来把值显式地从一种类型转换为另一种类型，如下所示： (type_name) expression 请看下面的实例，使用强制类型转换运算符把一个整数变量除以另一个整数变量，得到一个浮点数： #include <stdio.h> int main() { int sum = 17, coun.
C++:类型转换和类型安全
it_cplusplus
06-23 1144
C++:类型转换和类型安全简介隐式类型转换扩大转换（提升）收缩转换（强制）有符号到无符号的转换指针转换显式转换（强制转换） 简介 本文档确定了一些常见的类型转换问题，并介绍了如何在 C++ 代码中避免它们。 在编写 C++ 程序时，请务必确保它是类型安全的。 这意味着每个变量、函数自变量和函数返回值将存储一个可接受的类型的数据，并意味着涉及不同类型的值的操作“有意义”且不会导致数据丢失、位模式解释不正确或内存损坏。 从不显式或隐式地将值从一种类型转换为另一种类型的程序在定义上是类型安全的。 但是，有时需要进
c++ 类型转换与explicit
weixin_42923076的博客
05-09 549
c++ 类型转换与explicit 本文试图搞清楚这样2个问题： c++ 类型转换有哪些？作用分别是什么？实际工程中应该怎么用？ 经常查看标准库源码的同学会发现标准库中很多类构造函数会带有explicit声明，explicit关键字是为了做什么的？ 一、c++的类型转换简介 可不要上来就说4种类型转换昂。。类型转换按照触发条件分可分为：隐式类型转换，显式类型转换；而按照行为分可分为：static，dynamic，const，reinterpret。我们先按照行为划分介绍4种类型转换： 1. static
C++ 多继承和虚继承的内存布局
jschen10的专栏
10-18 1247
警告. 本文有点技术难度，需要读者了解C++和一些汇编语言知识。 在本文中，我们解释由gcc编译器实现多继承和虚继承的对象的布局。虽然在理想的C++程序中不需要知道这些编译器内部细节，但不幸的是多重继承（特别是虚拟继承）的实现方式有各种各样的不太明确的结论（尤其是，关于向下转型指针，使用指向指针的指针，还有虚拟基类的构造方法的调用命令）。 如果你了解多重继承是如何实现的，你就能预见到这些
C++学习总结20--多态(Polymorphic)
RedDrn的博客
12-29 565
小记：静默如初，安之若素 多态 虚函数覆盖（函数重写），多态概念 如果将基类中的某个成员函数声明为虚函数，那么其子类中与该函数具有相同原型的成员函数也是虚函数，并且对基类中的版本形成覆盖。 这时，通过指向子类对象的基类指针，或者通过引用子类对象的基类引用去调用虚函数，实际被执行的将是子类中的覆盖版本，而不再是基类中的原始版本，这种语法现象被称为多态。 class A { public: vi...
C++笔记 第五十五课 经典问题解析四---狄泰学院
YLC_慕类的博客
11-29 222
如果在阅读过程中发现有错误，望评论指正，希望大家一起学习，一起进步。 学习C++编译环境：Linux 第五十五课 经典问题解析四 1.关于动态内存分配 new和malloc的区别是什么？ delete和free的区别是什么？ new关键字与malloc函数的区别 new关键字是C++的一部分 malloc是由C库提供的函数 new以具体类型为单位进行内存分配 malloc以字节为单位进行内存分配 ...
C++学习笔记(Thinking in C++)五
libaohan的专栏
04-18 785
1、关于虚函数一些注意点  class Base{ public:         virtual void display(){                 cout         } }; class CTest: public Base{ public:         void display(){                 cout         }
c++ 学习错误列表
王定桥的专栏
03-03 4万+
c++ primer学习过程中调试常见错误归纳 这是学习c++ primer过程中练习程序时，调试时出现的错误即解决方法列表,不断更新。 No.1: prog2.cpp(8) : error C2664: '__thiscall std::list >::std::list >(unsigned int,const int &, const class std::allocator
terminate called after throwing an instance of 'std::cad_alloc' what():std::bad_alloc
热门推荐
一朝柯梦的博客
02-01 5万+
内存不够： 1，确认系统已占用内存是否正常，排除数据量过大导致的问题，此时系统内存不足导致 std::bad_alloc 内存剩余： 1，确认接口调用时，调用和背调接口的的参数是否一致，动态库库调用中若不一致，编译链接通过，但执行可能导致 std::bad_alloc 2，确认是否使用vector，vector超容量时会重新申请二倍内存，因为vector会将老的一块内存，完全拷贝到另一块连...
Tensorflow:terminate called after throwing an instance of 'std::bad_alloc' what(): std::bad_alloc
yangyang_liu的博客
04-13 1万+
在tensorflow教程深入mnist这一部分，如果照搬CNN代码，会出现terminate called after throwing an instance of 'std::bad_alloc'   what():  std::bad_alloc  Process finished with exit code 134 (interrupted by signal 6: SIGABRT)这
terminate called after throwing an instance of 'std::bad_alloc'
打过ICPC/CCPC，学习ACM算法，Linux内核，Openharmony，加油努力开心珍惜
07-27 2万+
今天敲代码时突然碰到一个奇怪的运行bug，有点懵逼，如下。 terminate called after throwing an instance of 'std::bad_alloc' 后来发现我的问题在于跑bfsbfsbfs的时候没有poppoppop点节点。导致内存炸掉，时间炸掉。 类似可能的原因应该还有vectorvectorvector不清空. 对了，有时候数组开大了，我的...
C/C++编程：数制转换与基础算法
在整个C/C++课程中，这部分知识是基础编程技能的重要组成部分，它涉及到数值表示的基础以及数据类型转换。通过实例和练习，学生能够理解并熟练运用这些技巧，以便于在实际编程中处理各种数值运算。 此外，课程还...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值