C++标准转换运算符dynamic_cast

简介:

dynamic_cast <new_type> (expression)

dynamic_cast运算符,应该算是四个里面最特殊的一个,因为它涉及到编译器的属性设置,而且牵扯到的面向对象的多态性跟程序运行时的状态也有关系,所以不能完全的使用传统的转换方式来替代。但是也因此它是最常用,最不可缺少的一个运算符。

static_cast一样,dynamic_cast的转换也需要目标类型和源对象有一定的关系:继承关系。 更准确的说,dynamic_cast是用来检查两者是否有继承关系。因此该运算符实际上只接受基于类对象的指针和引用的类转换。从这个方面来看,似乎dynamic_cast又和reinterpret_cast是一致的,但实际上,它们还是存在着很大的差别。

还是用代码来解释,让编译器来说明吧。


/////////////////////////////////////////////////////////////////////////////
// cast_operator_comparison.cpp                                                      
// Language:   C++                   
// Complier:    Visual Studio 2010, Xcode3.2.6 
// Platform: MacBook Pro 2010 // Application: none // Author: Ider, Syracuse University ider.cs@gmail.com /////////////////////////////////////////////////////////////////////////// #include <string> #include <iostream> using namespace std; class Parents { public: Parents(string n="Parent"){ name = n;} virtual ~Parents(){} virtual void Speak() { cout << "\tI am " << name << ", I love my children." << endl; } void Work() { cout << "\tI am " << name <<", I need to work for my family." << endl;; } protected: string name; }; class Children : public Parents { public: Children(string n="Child"):Parents(n){ } virtual ~Children(){} virtual void Speak() { cout << "\tI am " << name << ", I love my parents." << endl; } /* **Children inherit Work() method from parents, **it could be treated like part-time job. */ void Study() { cout << "\tI am " << name << ", I need to study for future." << endl;; } private: //string name; //Inherit "name" member from Parents }; class Stranger { public: Stranger(string n="stranger"){name = n;} virtual ~Stranger(){} void Self_Introduce() { cout << "\tI am a stranger" << endl; } void Speak() { //cout << "I am a stranger" << endl; cout << "\tDo not talk to "<< name << ", who is a stranger." << endl; } private: string name; }; int main() { /******* cast from child class to base class *******/ cout << "dynamic_cast from child class to base class:" << endl; Children * daughter_d = new Children("Daughter who pretend to be my mother"); Parents * mother_d = dynamic_cast<Parents*> (daughter_d); //right, cast with polymorphism mother_d->Speak(); mother_d->Work(); //mother_d->Study(); //Error, no such method cout << "static_cast from child class to base class:" << endl; Children * son_s = new Children("Son who pretend to be my father"); Parents * father_s = static_cast<Parents*> (son_s); //right, cast with polymorphism father_s->Speak(); father_s->Work(); //father_s->Study(); //Error, no such method cout << endl; /******* cast from base class to child class *******/ cout << "dynamic_cast from base class to child class:" << endl; Parents * father_d = new Parents("Father who pretend to be a my son"); Children * son_d = dynamic_cast<Children*> (father_d); //no error, but not safe if (son_d) { son_d->Speak(); son_d->Study(); } else cout << "\t[null]" << endl; cout << "static_cast from base class to child class:" << endl; Parents * mother_s = new Parents("Mother who pretend to be a my daugher"); Children * daughter_s = static_cast<Children*> (mother_s); //no error, but not safe if (daughter_s) { daughter_s->Speak(); daughter_s->Study(); } else cout << "\t[null]" << endl; cout << endl; /******* cast between non-related class *******/ cout << "dynamic_cast to non-related class:" << endl; Stranger* stranger_d = dynamic_cast<Stranger*> (daughter_d); if (stranger_d) { stranger_d->Self_Introduce(); stranger_d->Speak(); } else cout <<"\t[null]"<<endl; //Stranger* stranger_s = static_cast<Stranger*> (son_s); //Error, invalid cast cout << "reinterpret_cast to non-related class:" << endl; Stranger* stranger_r = reinterpret_cast<Stranger*> (son_s); if (stranger_r) { stranger_d->Self_Introduce(); //stranger_d->Speak(); //This line would cause program crush, //as "name" could not be found corretly. } else cout << "\t[null]" << endl; cout << endl; /******* cast back*******/ cout << "use dynamic_cast to cast back from static_cast:" << endl; Children* child_s = dynamic_cast<Children*> (father_s); if (child_s) { child_s->Speak(); child_s->Work(); } else cout << "\t[null]" << endl; //cout<<typeid(stranger_r).name()<<endl; cout << "use dynamic_cast to cast back from reinterpret_cast:" << endl; Children* child_r = dynamic_cast<Children*> (stranger_r); if (child_r) { child_r->Speak(); child_r->Work(); } else cout << "\t[null]" << endl; delete daughter_d; delete son_s; delete father_d; delete mother_s; return 0; } /********************* Result *********************/ //dynamic_cast from child class to base class: // I am Daughter who pretend to be my mother, I love my parents. // I am Daughter who pretend to be my mother, I need to work for my family. //static_cast from child class to base class: // I am Son who pretend to be my father, I love my parents. // I am Son who pretend to be my father, I need to work for my family. // //dynamic_cast from base class to child class: // [null] //static_cast from base class to child class: // I am Mother who pretend to be a my daugher, I love my children. // I am Mother who pretend to be a my daugher, I need to study for future. // //dynamic_cast to non-related class: // [null] //reinterpret_cast to non-related class: // I am a stranger // //use dynamic_cast to cast back from static_cast: // I am Son who pretend to be my father, I love my parents. // I am Son who pretend to be my father, I need to work for my family. //use dynamic_cast to cast back from reinterpret_cast: // [null] 

从上边的代码和输出结果可以看出:

对于从子类到基类的指针转换,static_cast和dynamic_cast都是成功并且正确的(所谓成功是说转换没有编译错误或者运行异常;所谓正确是指方法的调用和数据的访问输出是期望的结果),这是面向对象多态性的完美体现。

从基类到子类的转换,static_cast和dynamic_cast都是成功的,但是正确性方面,我对两者的结果都先进行了是否非空的判别:dynamic_cast的结果显示是空指针,而static_cast则是非空指针。但很显然,static_cast的结果应该算是错误的,子类指针实际所指的是基类的对象,而基类对象并不具有子类的Study()方法(除非妈妈又想去接受个"继续教育")。

对于没有关系的两个类之间的转换,输出结果表明,dynamic_cast依然是返回一个空指针以表示转换是不成立的;static_cast直接在编译期就拒绝了这种转换。

reinterpret_cast成功进行了转换,而且返回的值并不是空指针,但是结果显然是错误的,因为Children类显然不具有Stranger的Self_Introduce()。虽然两者都具有name数据成员和Speak()方法,,Speak()方法也只是调用了该相同名称的成员而已,但是对于Speak()的调用直接造成了程序的崩溃。

其实前面static_cast的转换的结果也会跟reinterpret_cast一样造成的程序的崩溃,只是类的方法都只有一份,只有数据成员属于对象,所以在调用那些不会访问对象的数据的方法时(如Stranger的Self_Introduce())并不会造成崩溃。而daughter_s->Speak();和daughter_s->Study();调用了数据成员却没有出现运行错误,则是因为该成员是从基类继承下来的,通过地址偏移可以正确的到达数据成员所在的地址以读取出数据。

最后,程序里还用dynamic_cast希望把用其他转换运算符转换过去的指针转换回来。对于使用static_cast转换后指向了子类对象的基类指针,dynamic_cast判定转换是合理有效的,因此转换成功获得一个非空的指针并且正确输出了结果;而对于reinterpret_cast转换的类型,的确如它的功能一样——重新解析,变成新的类型,所以才得到dynamic_cast判定该类型已经不是原来的类型结果,转换得到了一个空指针。

总得说来,static_cast和reinterpret_cast运算符要么直接被编译器拒绝进行转换,要么就一定会得到相应的目标类型的值。 而dynamic_cast却会进行判别,确定源指针所指的内容,是否真的合适被目标指针接受。如果是否定的,那么dynamic_cast则会返回null。这是通过检查"运行期类型信息"(Runtime type information,RTTI)来判定的,它还受到编译器的影响,有些编译器需要设置开启才能让程序正确运行(导师的PPT详细介绍了Visual Studio的情况),因此dynamic_cast也就不能用传统的转换方式来实现了。

虚函数(virtual function)对dynamic_cast的作用

已经在前面反复提到过面向对象的多态性,但是这个多态性到底要如何体现呢?dynamic_cast真的允许任意对象指针之间进行转换,只是最后返回个null值来告知转换无结果吗?

实际上,这一切都是虚函数(virtual function)在起作用。

在C++的面对对象思想中,虚函数起到了很关键的作用,当一个类中拥有至少一个虚函数,那么编译器就会构建出一个虚函数表(virtual method table)来指示这些函数的地址,假如继承该类的子类定义并实现了一个同名并具有同样函数签名(function siguature)的方法重写了基类中的方法,那么虚函数表会将该函数指向新的地址。此时多态性就体现出来了:当我们将基类的指针或引用指向子类的对象的时候,调用方法时,就会顺着虚函数表找到对应子类的方法而非基类的方法。

当然虚函数表的存在对于效率上会有一定的影响,首先构建虚函数表需要时间,根据虚函数表寻到到函数也需要时间。

因为这个原因如果没有继承的需要,一般不必在类中定义虚函数。但是对于继承来说,虚函数就变得很重要了,这不仅仅是实现多态性的一个重要标志,同时也是dynamic_cast转换能够进行的前提条件。

假如去掉上个例子中Stranger类析构函数前的virtual,那么语句
Children* child_r = dynamic_cast<Children*> (stranger_r);

在编译期就会直接报出错误,具体原因不是很清楚,我猜测可能是因为当类没有虚函数表的时候,dynamic_cast就不能用RTTI来确定类的具体类型,于是就直接不通过编译。

这不仅仅是没有继承关系的类之间的情况,如果基类或者子类没有任何虚函数(如果基类有虚函数表,子类当然是自动继承了该表),当他们作为dynamic_cast的源类型进行转换时,编译也会失败。

这种情况是有可能存在的,因为在设计的时候,我们可能不需要让子类重写任何基类的方法。但实际上,这是不合理的。导师在讲解多态性的时候,时刻强调了一点:如果要用继承,那么一定要让析构函数是虚函数;如果一个函数是虚函数,那么在子类中也要是虚函数。

我会将导师关于"为何继承中析构函数必须是虚函数"的讲解总结一下,当然你也可以看这边文章来了解原因。

目录
相关文章
|
11天前
|
C++
c++学习笔记02 运算符
C++学习笔记,介绍了C++中的运算符,包括基本的加减乘除、求模、前后置递增递减、赋值运算符、比较运算符和逻辑运算符的使用及其注意事项。
25 6
|
3月前
|
C++
C++之运算符
C++之运算符
23 1
|
3月前
|
安全 程序员 C++
C++一分钟之-重载运算符
【6月更文挑战第21天】C++的运算符重载让程序员能为自定义类型定制运算符行为,增强代码表达力。但要注意清晰性、优先级和返回类型。遵循运算符原有意义,充分测试,并用注释解释非直观设计。示例展示了如何为复数类重载`+`运算符。避免重载内置类型,注意结合性,且慎用隐式转换。重载应提升可读性而非复杂化代码。
32 2
|
3月前
|
C++
C++一分钟之-理解C++的运算符与表达式
【6月更文挑战第18C++的运算符和表达式构成了编程的基础,涉及数学计算、逻辑判断、对象操作和内存管理。算术、关系、逻辑、位、赋值运算符各有用途,如`+`、`-`做加减,`==`、`!=`做比较。理解运算符优先级和结合律至关重要。常见错误包括优先级混淆、整数除法截断、逻辑运算符误用和位运算误解。解决策略包括明确优先级、确保浮点数除法、正确使用逻辑运算符和谨慎进行位运算。通过实例代码学习,如 `(a &gt; b) ? &quot;greater&quot; : &quot;not greater&quot;`,能够帮助更好地理解和应用这些概念。掌握这些基础知识是编写高效、清晰C++代码的关键。
28 3
|
4月前
|
C++
c++运算符
c++运算符
39 2
|
3月前
|
编译器 C++
C++运算符的重载
C++运算符的重载
20 0
|
18天前
|
C++ 容器
C++中自定义结构体或类作为关联容器的键
C++中自定义结构体或类作为关联容器的键
25 0
|
18天前
|
存储 算法 搜索推荐
【C++】类的默认成员函数
【C++】类的默认成员函数
|
17天前
|
存储 安全 编译器
【C++】类和对象(下)
【C++】类和对象(下)
【C++】类和对象(下)
下一篇
云函数