c++面向对象复习题答案版_百度文库
两大类热门资源免费畅读
续费一年阅读会员，立省24元！
评价文档：
c++面向对象复习题答案版
阅读已结束，如果下载本文需要使用
想免费下载本文？
把文档贴到Blog、BBS或个人站等：
普通尺寸(450*500pix)
较大尺寸(630*500pix)
你可能喜欢88673人阅读
&&&&&&& C++编程语言是一款应用广泛，支持多种程序设计的计算机编程语言。我们今天就会为大家详细介绍其中C++多态性的一些基本知识，以方便大家在学习过程中对此能够有一个充分的掌握。
　　多态性可以简单地概括为“一个接口，多种方法”，程序在运行时才决定调用的函数，它是面向对象编程领域的核心概念。多态(polymorphism)，字面意思多种形状。
　　C++多态性是通过虚函数来实现的，虚函数允许子类重新定义成员函数，而子类重新定义父类的做法称为覆盖(override)，或者称为重写。（这里我觉得要补充，重写的话可以有两种，直接重写成员函数和重写虚函数，只有重写了虚函数的才能算作是体现了C++多态性）而重载则是允许有多个同名的函数，而这些函数的参数列表不同，允许参数个数不同，参数类型不同，或者两者都不同。编译器会根据这些函数的不同列表，将同名的函数的名称做修饰，从而生成一些不同名称的预处理函数，来实现同名函数调用时的重载问题。但这并没有体现多态性。
　　多态与非多态的实质区别就是函数地址是早绑定还是晚绑定。如果函数的调用，在编译器编译期间就可以确定函数的调用地址，并生产代码，是静态的，就是说地址是早绑定的。而如果函数调用的地址不能在编译器期间确定，需要在运行时才确定，这就属于晚绑定。
　　那么多态的作用是什么呢，封装可以使得代码模块化，继承可以扩展已存在的代码，他们的目的都是为了代码重用。而多态的目的则是为了接口重用。也就是说，不论传递过来的究竟是那个类的对象，函数都能够通过同一个接口调用到适应各自对象的实现方法。
　　最常见的用法就是声明基类的指针，利用该指针指向任意一个子类对象，调用相应的虚函数，可以根据指向的子类的不同而实现不同的方法。如果没有使用虚函数的话，即没有利用C++多态性，则利用基类指针调用相应的函数的时候，将总被限制在基类函数本身，而无法调用到子类中被重写过的函数。因为没有多态性，函数调用的地址将是一定的，而固定的地址将始终调用到同一个函数，这就无法实现一个接口，多种方法的目的了。
笔试题目：
#include&iostream&
void foo()
printf(&1\n&);
virtual void fun()
printf(&2\n&);
class B : public A
void foo()
printf(&3\n&);
void fun()
printf(&4\n&);
int main(void)
A *p = &a;
}&&&&& 第一个p-&foo()和p-&fuu()都很好理解，本身是基类指针，指向的又是基类对象，调用的都是基类本身的函数，因此输出结果就是1、2。
&　& 第二个输出结果就是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&
class Base
virtual void f(float x)
cout&&&Base::f(float)&&& x &&
void g(float x)
cout&&&Base::g(float)&&& x &&
void h(float x)
cout&&&Base::h(float)&&& x &&
class Derived : public Base
virtual void f(float x)
cout&&&Derived::f(float)&&& x &&
//多态、覆盖
void g(int x)
cout&&&Derived::g(int)&&& x &&
void h(float x)
cout&&&Derived::h(float)&&& x &&
int main(void)
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)
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
}令人迷惑的隐藏规则
本来仅仅区别重载与覆盖并不算困难，但是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++纯虚函数
& 纯虚函数是在基类中声明的虚函数，它在基类中没有定义，但要求任何派生类都要定义自己的实现方法。在基类中实现纯虚函数的方法是在函数原型后加“=0”
& virtual void funtion()=0
二、引入原因
&& 1、为了方便使用多态特性，我们常常需要在基类中定义虚拟函数。
&& 2、在很多情况下，基类本身生成对象是不合情理的。例如，动物作为一个基类可以派生出老虎、孔雀等子类，但动物本身生成对象明显不合常理。
& 为了解决上述问题，引入了纯虚函数的概念，将函数定义为纯虚函数（方法：virtual ReturnType Function()= 0;），则编译器要求在派生类中必须予以重写以实现多态性。同时含有纯虚拟函数的类称为抽象类，它不能生成对象。这样就很好地解决了上述两个问题。
三、相似概念
&& 1、多态性
& 指相同对象收到不同消息或不同对象收到相同消息时产生不同的实现动作。C++支持两种多态性：编译时多态性，运行时多态性。
& a、编译时多态性：通过重载函数实现
& b、运行时多态性：通过虚函数实现。
& 2、虚函数
& 虚函数是在基类中被声明为virtual，并在派生类中重新定义的成员函数，可实现成员函数的动态覆盖（Override）
& 3、抽象类
& 包含纯虚函数的类称为抽象类。由于抽象类包含了没有定义的纯虚函数，所以不能定义抽象类的对象。
版权声明：本文为博主原创文章，未经博主允许不得转载。
* 以上用户言论只代表其个人观点，不代表CSDN网站的观点或立场
访问：2364753次
积分：25641
积分：25641
排名：第103名
原创：254篇
评论：2357条
文章：14篇
阅读：23546
文章：19篇
阅读：409001
(1)(9)(1)(2)(4)(2)(2)(9)(2)(9)(10)(19)(20)(16)(18)(2)(2)(19)(10)(61)(14)(30)C++中两个抽象类中的纯虚函数同名，用同一类去继承此抽象类，如何区分两个同名函数_百度知道
C++中两个抽象类中的纯虚函数同名，用同一类去继承此抽象类，如何区分两个同名函数
提问者采纳
加上抽象类名:: 类作用域用类作用域
不是很明白啊。我有两个抽象类class Pormotable{public:virtual void promoting() = 0;}class GoodEmployee{public:virtual void promoting() = 0;}class Manager:public Promotable,public GoodEmployee{public://此处如何区分两个纯虚函数?}
class Manager:public Promotable,public GoodEmployee{public:Pormotable::promoting();GoodEmployee::promoting();}
提问者评价
感谢感谢啊
来自团队：
其他类似问题
为您推荐：
您可能关注的推广
纯虚函数的相关知识
其他2条回答
::作用域符号
不是很明白啊。我有两个抽象类class Pormotable{public:virtual void promoting() = 0;}class GoodEmployee{public:virtual void promoting() = 0;}class Manager:public Promotable,public GoodEmployee{public://此处如何区分两个纯虚函数?}
看各个的形式参数
等待您来回答
下载知道APP
随时随地咨询
出门在外也不愁一.继承和派生
基类（父类）：原有的类
派生类（子类）：基于基类新建立的类
派生（类的派生）：在原有类的基础上建立新类并且添加新特征的过程
继承：子类不加修改延续父类的特征
2.单一继承：子类只有一个基类的继承
多重继承：子类拥有多个基类的继承叫多重继承
3.使用冒号（：）来声明派生类（子类）：
class 子类：public 父类
上面的声明表示冒号前面的类（子类）是从冒号后面的类（父类）派生来的,注意父类前面必须使用public来修饰，否则子类对象不能赋值给父类的对象
4.protect修饰符
protect：只有自身和子类才能访问，其他类不能访问
private：只有自身才能访问，其他类不能访问
public：所有都能访问
5.子类和父类之间的赋值
class father
class son:public father
father a；
a=b;//可以
b=a;//不行
注意：父类对象不能赋值给子类的对象，这是因为父类的对象成员比子类的对象成员少（子类会增加一些新功能），如果使用子类对象访问父类的成员，可能出现找不到成员的现象，导致程序出错。
6.定义子类构造函数
6.1 定义形式：
子类：子类构造函数（参数）：父类1（参数），父类2（参数）。。。
6.2 构造函数的执行顺序：首先调用基类的构造函数，在执行子类的构造函数；释放对象时，先调用子类的析构函数，再调用父类的析构函数
7.解决程序的两义性问题：
void hello(){cout&&&我是父类A&&&}
void hello(){cout&&&我是父类B&&&}
class C:public A,public B
void hello(){cout&&&我是子类C&&&}
void main()
c.hello();//输出“我是子类C”
在main函数中调用hello函数，会执行子类C的hello函数，但是如果我想输出父类A的hello函数，那么就应该使用
作用域操作符（::） 用它来指定函数属于那个类：
c.A::hello();
这样就能输出“我是父类A”
如果使用父类的指针来访问子类的对象成员，那么他能执行到子类的成员吗？看下面的例子：
class falther
void run()
cout&&&父亲可以跑万米！&&&
class son:public falther
void run()
cout&&&儿子可以跑一百万米！&&&
void main()
falther *fa=new son();
fa-&run();//输出“父亲可以跑万米”
没错，使用父指针fa不能访问子对象的函数run，那么怎么才能输出“儿子可以跑一百万米”呢？
解决办法：在父类的函数run前面加上关键字virtual，也就是父类是虚函数，然后使用系统执行到关键字virtual函数的时候，就会自动判断哪个对象调用了它，然后调用该对象的同名函数，修改程序如下：
class falther
virtual void run()
cout&&&父亲可以跑万米！&&&
class son:public falther
void run()
cout&&&儿子可以跑一百万米！&&&
void main()
falther *fa=new son();
fa-&run();//输出“儿子可以跑一百万米”
上面使用父指针就可以输出了“儿子可以跑一百万米”
&三.多态性（c++三大特性：封装性，继承性，多态性）
以上面的father和son的例子解释多态性：
&&&&& 当c++编译器在编译的时候，发现father类的run（）函数是虚函数，这个时候c++就会采用迟绑定（late binding）技术。也就是编译时不确定具体调用的函数，而是在运行时，根据对象的类型（在程序中，我们传递的是son类对象的地址）来确认是哪个函数，这种能力就叫做c++的多态性。我们如果没有在father类的run（）前加上vitual关键字，c++编译器在编译时就确定了哪个函数被调用（调用father中的run），这叫做早期绑定（early
binding）。
&&&&&c++多态性概念：在基类的函数前加上virtual关键字，在派生类中重写该函数，运行时就会根据对象的实际类型调用相应的函数。也就是说如果对象类型是派生类，就调用派生类的函数；如果对象类型是基类，就调用基类的函数。
&&& 注意：c++的多态性只能通过虚函数来体现。
四.纯虚函数和抽象类
class falther{public: virtual void run()=0;}
上面在father类中的虚函数run的函数体=0，这种定义方式就定义一个纯虚函数run。
纯虚函数是指被标明为不具体实现的虚函数，它让类先有一个操作名称，而没有操作内容，让派生类在继承的时候去具体的实现。凡是含有纯虚函数的类就叫做抽象类。抽象类是不能声明一个对象的，只能作为基类为派生类服务。因为抽象类声明一个对象，调用其函数是没有意义的。注意：如果派生类也没具体的实现抽象类中的纯虚函数，那么派生类也会变成一个抽象类，不能实例化对象。
版权声明：本文为博主原创文章，未经博主允许不得转载。
* 以上用户言论只代表其个人观点，不代表CSDN网站的观点或立场
访问：50442次
排名：千里之外
原创：22篇
评论：29条
(1)(12)(9)