C++多态性等
来源:互联网 发布:c语言double 编辑:程序博客网 时间:2024/05/13 07:41
C++编程语言是一款应用广泛,支持多种程序设计的计算机编程语言。我们今天就会为大家详细介绍其中C++多态性的一些基本知识,以方便大家在学习过程中对此能够有一个充分的掌握。
多态性可以简单地概括为“一个接口,多种方法”,程序在运行时才决定调用的函数,它是面向对象编程领域的核心概念。多态(polymorphisn),字面意思多种形状。C++多态性是通过虚函数来实现的,虚函数允许子类重新定义成员函数,而子类重新定义父类的做法称为覆盖(override),或者称为重写。(这里我觉得要补充,重写的话可以有两种,直接重写成员函数和重写虚函数,只有重写了虚函数的才能算作是体现了C++多态性)而重载则是允许有多个同名的函数,而这些函数的参数列表不同,允许参数个数不同,参数类型不同,或者两者都不同。编译器会根据这些函数的不同列表,将同名的函数的名称做修饰,从而生成一些不同名称的预处理函数,来实现同名函数调用时的重载问题。但这并没有体现多态性。
多态与非多态的实质区别就是函数地址是早绑定还是晚绑定。如果函数的调用,在编译器编译期间就可以确定函数的调用地址,并生产代码,是静态的,就是说地址是早绑定的。而如果函数调用的地址不能在编译器期间确定,需要在运行时才确定,这就属于晚绑定。
那么多态的作用是什么呢,封装可以使得代码模块化,继承可以扩展已存在的代码,他们的目的都是为了代码重用。而多态的目的则是为了接口重用。也就是说,不论传递过来的究竟是那个类的对象,函数都能够通过同一个接口调用到适应各自对象的实现方法。
最常见的用法就是声明基类的指针,利用该指针指向任意一个子类对象,调用相应的虚函数,可以根据指向的子类的不同而实现不同的方法。如果没有使用虚函数的话,即没有利用C++多态性,则利用基类指针调用相应的函数的时候,将总被限制在基类函数本身,而无法调用到子类中被重写过的函数。因为没有多态性,函数调用的地址将是一定的,而固定的地址将始终调用到同一个函数,这就无法实现一个接口,多种方法的目的了。
笔试题目:
- #include<iostream>
- using namespace std;
- class A
- {
- public:
- void foo()
- {
- printf("1\n");
- }
- virtual void fun()
- {
- printf("2\n");
- }
- };
- class B : public A
- {
- public:
- void foo()
- {
- printf("3\n");
- }
- void fun()
- {
- printf("4\n");
- }
- };
- int main(void)
- {
- A a;
- B b;
- A *p = &a;
- p->foo();
- p->fun();
- p = &b;
- p->foo();
- p->fun();
- return 0;
- }
第二个输出结果就是1、4。p->foo()和p->fuu()则是基类指针指向子类对象,正式体现多态的用法,p->foo()由于指针是个基类指针,指向是一个固定偏移量的函数,因此此时指向的就只能是基类的foo()函数的代码了,因此输出的结果还是1。而p->fun()指针是基类指针,指向的fun是一个虚函数,由于每个虚函数都有一个虚函数列表,此时p调用fun()并不是直接调用函数,而是通过虚函数列表找到相应的函数的地址,因此根据指向的对象不同,函数地址也将不同,这里将找到对应的子类的fun()函数的地址,因此输出的结果也会是子类的结果4。
笔试的题目中还有一个另类测试方法。即
B *ptr = (B *)&a; ptr->foo(); ptr->fun();
问这两调用的输出结果。这是一个用子类的指针去指向一个强制转换为子类地址的基类对象。结果,这两句调用的输出结果是3,2。
并不是很理解这种用法,从原理上来解释,由于B是子类指针,虽然被赋予了基类对象地址,但是ptr->foo()在调用的时候,由于地址偏移量固定,偏移量是子类对象的偏移量,于是即使在指向了一个基类对象的情况下,还是调用到了子类的函数,虽然可能从始到终都没有子类对象的实例化出现。
而ptr->fun()的调用,可能还是因为C++多态性的原因,由于指向的是一个基类对象,通过虚函数列表的引用,找到了基类中fun()函数的地址,因此调用了基类的函数。由此可见多态性的强大,可以适应各种变化,不论指针是基类的还是子类的,都能找到正确的实现方法。
- //小结:1、有virtual才可能发生多态现象
- // 2、不发生多态(无virtual)调用就按原类型调用
- #include<iostream>
- using namespace std;
- class Base
- {
- public:
- virtual void f(float x)
- {
- cout<<"Base::f(float)"<< x <<endl;
- }
- void g(float x)
- {
- cout<<"Base::g(float)"<< x <<endl;
- }
- void h(float x)
- {
- cout<<"Base::h(float)"<< x <<endl;
- }
- };
- class Derived : public Base
- {
- public:
- virtual void f(float x)
- {
- cout<<"Derived::f(float)"<< x <<endl; //多态、覆盖
- }
- void g(int x)
- {
- cout<<"Derived::g(int)"<< x <<endl; //隐藏
- }
- void h(float x)
- {
- cout<<"Derived::h(float)"<< x <<endl; //隐藏
- }
- };
- int main(void)
- {
- Derived d;
- Base *pb = &d;
- Derived *pd = &d;
- // Good : behavior depends solely on type of the object
- pb->f(3.14f); // Derived::f(float) 3.14
- pd->f(3.14f); // Derived::f(float) 3.14
- // Bad : behavior depends on type of the pointer
- pb->g(3.14f); // Base::g(float) 3.14
- pd->g(3.14f); // Derived::g(int) 3
- // Bad : behavior depends on type of the pointer
- pb->h(3.14f); // Base::h(float) 3.14
- pd->h(3.14f); // Derived::h(float) 3.14
- return 0;
- }
本来仅仅区别重载与覆盖并不算困难,但是C++的隐藏规则使问题复杂性陡然增加。
这里“隐藏”是指派生类的函数屏蔽了与其同名的基类函数,规则如下:
(1)如果派生类的函数与基类的函数同名,但是参数不同。此时,不论有无virtual
关键字,基类的函数将被隐藏(注意别与重载混淆)。
(2)如果派生类的函数与基类的函数同名,并且参数也相同,但是基类函数没有virtual
关键字。此时,基类的函数被隐藏(注意别与覆盖混淆)。
上面的程序中:
(1)函数Derived::f(float)覆盖了Base::f(float)。
(2)函数Derived::g(int)隐藏了Base::g(float),而不是重载。
(3)函数Derived::h(float)隐藏了Base::h(float),而不是覆盖。
c++ 重载 覆盖 隐藏的区别和执行方式
(1)相同的范围(在同一个类中);
(2)函数名字相同;
(3)参数不同;
(4)virtual 关键字可有可无。
覆盖是指派生类函数覆盖基类函数,特征是
(1)不同的范围(分别位于派生类与基类);
(2)函数名字相同;
(3)参数相同;
(4)基类函数必须有virtual 关键字。
“隐藏”是指派生类的函数屏蔽了与其同名的基类函数,规则如下
(1)如果派生类的函数与基类的函数同名,但是参数不同。此时,不论有无virtual关键字,基类的函数将被隐藏(注意别与重载混淆)。
(2)如果派生类的函数与基类的函数同名,并且参数也相同,但是基类函数没有virtual 关键字。此时,基类的函数被隐藏(注意别与覆盖混淆)
重载(overload),覆盖(override),隐藏(hide)的区别 (转自清风明月轩 http://www.cnblogs.com/txwsh1/archive/2008/06/28/1231751.html
http://www.cppblog.com/zgysx/archive/2007/03/12/19662.html
写正题之前,先给出几个关键字的中英文对照,重载(overload),覆盖(override),隐藏(hide)。在早期的C++书籍中,可能翻译的人不熟悉专业用语(也不能怪他们,他们不是搞计算机编程的,他们是英语专业的),常常把重载(overload)和覆盖(override)搞错!我们先来看一些代码及其编译结果。
实例一:
- #include "stdafx.h"
- #include <iostream.h>
- class CB
- {
- public:
- void f(int)
- {
- cout << "CB::f(int)" << endl;
- }
- };
- class CD : public CB
- {
- public:
- void f(int,int)
- {
- cout << "CD::f(int,int)" << endl;
- }
- void test()
- {
- f(1);
- }
- };
- int main(int argc, char* argv[])
- {
- return 0;
- }
编译了一下
error C2660: 'f' : function does not take 1 parameters
结论:在类CD这个域中,没有f(int)这样的函数,基类中的void f(int)被隐藏
如果把派生CD中成员函数void f(int,int)的声明改成和基类中一样,即f(int),基类中的void f(int)还是一样被覆盖,此时编译不会出错,在函数中test调用的是CD中的f(int)
所以,在基类中的某些函数,如果没有virtral关键字,函数名是f(参数是什么我们不管),那么如果在派生类CD中也声明了某个f成员函数,那么在类CD域中,基类中所有的那些f都被隐藏。
如果你比较心急,想知道什么是隐藏,看文章最后的简单说明,不过我建议你还是一步一步看下去。
我们刚才说的是没有virtual的情况,如果有virtual的情况呢??
实例二:
- #include "stdafx.h"
- #include <iostream.h>
- class CB
- {
- public:
- virtual void f(int)
- {
- cout << "CB::f(int)" << endl;
- }
- };
- class CD : public CB
- {
- public:
- void f(int)
- {
- cout << "CD::f(int)" << endl;
- }
- };
- int main(int argc, char* argv[])
- {
- return 0;
- }
这么写当然是没问题了,在这里我不多费口舌了,这是很简单的,多态,虚函数,然后什么指向基类的指针指向派生类对象阿,通过引用调用虚函数阿什么的,属性多的很咯,什么??你不明白??随便找本C++的书,对会讲多态和虚函数机制的哦!!
这种情况我们叫覆盖(override)!覆盖指的是派生类的虚拟函数覆盖了基类的同名且参数相同的函数!
在这里,我要强调的是,这种覆盖,要满足两个条件
(a)有virtual关键字,在基类中函数声明的时候加上就可以了
(b)基类CB中的函数和派生类CD中的函数要一模一样,什么叫一模一样,函数名,参数,返回类型三个条件。
有人可能会对(b)中的说法质疑,说返回类型也要一样??
是,覆盖的话必须一样,我试了试,如果在基类中,把f的声明改成virtual int f(int),编译出错了
error C2555: 'CD::f' : overriding virtual function differs from 'CB::f' only by return type or calling convention
所以,覆盖的话,必须要满足上述的(a)(b)条件
那么如果基类CB中的函数f有关键字virtual ,但是参数和派生类CD中的函数f参数不一样呢,
实例三:
- #include "stdafx.h"
- #include <iostream.h>
- class CB
- {
- public:
- virtual void f(int)
- {
- cout << "CB::f(int)" << endl;
- }
- };
- class CD : public CB
- {
- public:
- void f(int,int)
- {
- cout << "CD::f(int,int)" << endl;
- }
- void test()
- {
- f(1);
- }
- };
- int main(int argc, char* argv[])
- {
- return 0;
- }
编译出错了,
error C2660: 'f' : function does not take 1 parameters
咦??好面熟的错??对,和实例一中的情况一样哦,结论也是基类中的函数被隐藏了。
通过上面三个例子,得出一个简单的结论
如果基类中的函数和派生类中的两个名字一样的函数f
满足下面的两个条件
(a)在基类中函数声明的时候有virtual关键字
(b)基类CB中的函数和派生类CD中的函数一模一样,函数名,参数,返回类型都一样。
那么这就是叫做覆盖(override),这也就是虚函数,多态的性质
那么其他的情况呢??只要名字一样,不满足上面覆盖的条件,就是隐藏了。
下面我要讲最关键的地方了,好多人认为,基类CB中的f(int)会继承下来和CD中的f(int,int)在派生类CD中构成重载,就像实例一中想像的那样。
对吗?我们先看重载的定义
重载(overload):
必须在一个域中,函数名称相同但是函数参数不同,重载的作用就是同一个函数有不同的行为,因此不是在一个域中的函数是无法构成重载的,这个是重载的重要特征
必须在一个域中,而继承明显是在两个类中了哦,所以上面的想法是不成立的,我们测试的结构也是这样,派生类中的f(int,int)把基类中的f(int)隐藏了
所以,相同的函数名的函数,在基类和派生类中的关系只能是覆盖或者隐藏。
在文章中,我把重载和覆盖的定义都给了出来了,但是一直没有给隐藏的定义,在最后,我把他给出来,这段话是网上google来的,比较长,你可以简单的理解成,在派生类域中,看不到基类中的那个同名函数了,或者说,是并没有继承下来给你用,呵呵,如实例一 那样。
隐藏(hide):
指的是派生类的成员函数隐藏了基类函数的成员函数.隐藏一词可以这么理解:在调用一个类的成员函数的时候,编译器会沿着类的继承链逐级的向上查找函数的定义,如果找到了那么就停止查找了,所以如果一个派生类和一个基类都有同一个同名(暂且不论参数是否相同)的函数,而编译器最终选择了在派生类中的函数,那么我们就说这个派生类的成员函数"隐藏"了基类的成员函数,也就是说它阻止了编译器继续向上查找函数的定义.
C++纯虚函数
一、定义
纯虚函数是在基类中声明的虚函数,它在基类中没有定义,但要求任何派生类都要定义自己的实现方法。在基类中实现纯虚函数的方法是在函数原型后加“=0”
virtual void funtion()=0
二、引入原因
1、为了方便使用多态特性,我们常常需要在基类中定义虚拟函数。
2、在很多情况下,基类本身生成对象是不合情理的。例如,动物作为一个基类可以派生出老虎、孔雀等子类,但动物本身生成对象明显不合常理。
为了解决上述问题,引入了纯虚函数的概念,将函数定义为纯虚函数(方法:virtual ReturnType Function()= 0;),则编译器要求在派生类中必须予以重写以实现多态性。同时含有纯虚拟函数的类称为抽象类,它不能生成对象。这样就很好地解决了上述两个问题。
三、相似概念
1、多态性
指相同对象收到不同消息或不同对象收到相同消息时产生不同的实现动作。C++支持两种多态性:编译时多态性,运行时多态性。
a、编译时多态性:通过重载函数实现
b、运行时多态性:通过虚函数实现。
2、虚函数
虚函数是在基类中被声明为virtual,并在派生类中重新定义的成员函数,可实现成员函数的动态覆盖(Override)
3、抽象类
包含纯虚函数的类称为抽象类。由于抽象类包含了没有定义的纯虚函数,所以不能定义抽象类的对象
- C++:多态性
- C++-多态性
- C++---多态性
- C+++多态性
- 【C#】多态性
- C++多态性等
- C++---------【多态性】之【静态多态性】
- 多态性C++[转]
- 多态性C++[转]
- C++:多态性 (三)
- c/c++中的多态性
- 【C#】C#多态性
- C++_多态性
- 5.2什么是多态性【C++】
- C#教程第九课:多态性
- C#教程 第九课:多态性
- C plus plus 的多态性
- C#教程第九课:多态性
- Android中Activity切换时共享视图元素的切换动画(4.x兼容方案)
- C++继承
- Execute failed: java.io.IOException: Cannot run program "sdk-linux/build-tools/22.0.0/aapt": error=2
- Hibernate-note02
- C++ 判断是大端存储还是小端存储
- C++多态性等
- Java中的static静态代码块
- app store怎么用支付宝充值
- iOS开发:StoryBoard 使用Block在两个界面之间传值
- 能被2、3、4、5、6、7、8、9、10等数整除的数的特征
- ajax提交form表单
- [c]sdnuoj 1088 欧拉路的判断
- 2015多校第四场两水题(2015 Multi-University Training Contest 4)
- Linux 网卡驱动学习(四)(缓存描述符 Buffer Description)