程序员面试宝典随笔记(一)-------C++中重载和覆盖和隐藏的区别
2018-01-14 22:21
323 查看
一. 重载(overload)
1. 重载指的是函数具有的不同的参数列表,而函数名相同的函数。重载要求参数列表必须不同,比如参数的类型不同、参数的个数不同、参数的顺序不同。
2. 如果仅仅是函数的返回值不同是没办法重载的,因为重载要求参数列表必须不同。
3. 程序是根据参数列表来确定具体要调用哪个函数的
4. 看下面几个例子
void Fun(int a);
void Fun(double a);
void Fun(int a, int b);
void Fun(double a, int b);
上面四个函数都可以构成函数重载
int Fun(int a)
void Fun(int a)
//上面两个是无法构成函数重载的,参数列表必须不同
二. 覆盖(重写override)
1. 覆盖是存在类中,子类重写从基类继承过来的函数。但是函数名、返回值、参数列表都必须和基类相同。
2. 当子类的对象调用成员函数的时候,如果成员函数有被覆盖则调用子类中覆盖的版本,否则调用从基类继承过来的函数
3. 如果子类覆盖的是基类的虚函数,可以用来实现多态。
当子类重新定义基类的虚函数之后,基类指针可以根据赋给它不同子类指针动态的调用子类中的虚函数,可以做到动态绑定,这就是多态。
4. 子类覆盖基类函数的特征
(1)函数名相同、参数相同、返回值相同
(2)如果基类函数是虚函数,子类覆盖虚函数可以实现多态
三. 重载和覆盖的区别
1. 重载要求函数名相同,但是参数列表必须不同,返回值可以相同也可以不同。
覆盖要求函数名、参数列表、返回值必须相同。
2. 在类中重载是同一个类中不同成员函数之间的关系
在类中覆盖则是子类和基类之间不同成员函数之间的关系
3. 重载函数的调用是根据参数列表来决定调用哪一个函数
覆盖函数的调用是根据对象类型的不同决定调用哪一个
4. 在类中对成员函数重载是不能够实现多态
在子类中对基类虚函数的覆盖可以实现多态
看下面这个例子
[cpp]
4000
view
plain copy
#include<iostream>
#include<algorithm>
using namespace std;
//基类
class Base{
public:
//基类Fun为重载函数
void Fun(int x){
cout<<"Base::Fun(int x)"<<endl;
}
void Fun(double x){
cout<<"Base::Fun(double x)"<<endl;
}
//基类虚函数
virtual void G(void){
cout<<"Base::G(void)"<<endl;
}
};
//子类
class SubClass:public Base{
public:
//隐藏基类的Fun函数
void Fun(int x){
cout<<"SubClass::Fun(int x)"<<endl;
}
void Fun(double x){
cout<<"SubClass::Fun(double x)"<<endl;
}
//覆盖基类虚函数
virtual void G(void){
cout<<"SubClass::G(void)"<<endl;
}
};
int main(){
Base *base = new Base();
SubClass *subClass = new SubClass();
base = subClass; //基类指针指向子类对象
//测试函数调用
base->Fun(5);
base->Fun(5.00);
base->G();
return 0;
}
输出结果
分析:
1. 定义一个基类Base,基类内部有两个重载函数Fun和一个虚函数G
2. 子类SubClass继承了基类Base,子类首先隐藏了基类的两个函数Fun并且覆盖了基类虚函数G;
如果基类函数是虚函数,那么子类重新定义就属于覆盖。
如果基类函数不是虚函数,那么子类重新定义属于隐藏基类函数
3. main函数内部,基类指针base指向子类对象指针subClass,然后调用三个函数
(1)base->Fun(5) 输出“Base::Fun(int x)”说明调用的是基类的函数,可以看出通过基类指针并不能动态的调用子类覆盖基类的非虚函数
(2)base->Fun(5.00) 和上面类似
(3)base->G() 输出"SubClass::G(void)" 说明调用的是子类的函数G,可以看出通过基类指针可以动态的调用子类覆盖基类的虚函数
由此可见,多态的实现是通过子类覆盖基类的虚函数,利用基类指针指向不同的子类对象,在运行的时候动态的决定要调用哪个子类虚函数。
一. 重载(overload)
1. 重载指的是函数具有的不同的参数列表,而函数名相同的函数。重载要求参数列表必须不同,比如参数的类型不同、参数的个数不同、参数的顺序不同。
2. 如果仅仅是函数的返回值不同是没办法重载的,因为重载要求参数列表必须不同。
3. 程序是根据参数列表来确定具体要调用哪个函数的
4. 看下面几个例子
void Fun(int a);
void Fun(double a);
void Fun(int a, int b);
void Fun(double a, int b);
上面四个函数都可以构成函数重载
int Fun(int a)
void Fun(int a)
//上面两个是无法构成函数重载的,参数列表必须不同
二. 覆盖(重写override)
1. 覆盖是存在类中,子类重写从基类继承过来的函数。但是函数名、返回值、参数列表都必须和基类相同。
2. 当子类的对象调用成员函数的时候,如果成员函数有被覆盖则调用子类中覆盖的版本,否则调用从基类继承过来的函数
3. 如果子类覆盖的是基类的虚函数,可以用来实现多态。
当子类重新定义基类的虚函数之后,基类指针可以根据赋给它不同子类指针动态的调用子类中的虚函数,可以做到动态绑定,这就是多态。
4. 子类覆盖基类函数的特征
(1)函数名相同、参数相同、返回值相同
(2)如果基类函数是虚函数,子类覆盖虚函数可以实现多态
三. 重载和覆盖的区别
1. 重载要求函数名相同,但是参数列表必须不同,返回值可以相同也可以不同。
覆盖要求函数名、参数列表、返回值必须相同。
2. 在类中重载是同一个类中不同成员函数之间的关系
在类中覆盖则是子类和基类之间不同成员函数之间的关系
3. 重载函数的调用是根据参数列表来决定调用哪一个函数
覆盖函数的调用是根据对象类型的不同决定调用哪一个
4. 在类中对成员函数重载是不能够实现多态
在子类中对基类虚函数的覆盖可以实现多态
看下面这个例子
[cpp] view
plain copy
#include<iostream>
#include<algorithm>
using namespace std;
//基类
class Base{
public:
//基类Fun为重载函数
void Fun(int x){
cout<<"Base::Fun(int x)"<<endl;
}
void Fun(double x){
cout<<"Base::Fun(double x)"<<endl;
}
//基类虚函数
virtual void G(void){
cout<<"Base::G(void)"<<endl;
}
};
//子类
class SubClass:public Base{
public:
//隐藏基类的Fun函数
void Fun(int x){
cout<<"SubClass::Fun(int x)"<<endl;
}
void Fun(double x){
cout<<"SubClass::Fun(double x)"<<endl;
}
//覆盖基类虚函数
virtual void G(void){
cout<<"SubClass::G(void)"<<endl;
}
};
int main(){
Base *base = new Base();
SubClass *subClass = new SubClass();
base = subClass; //基类指针指向子类对象
//测试函数调用
base->Fun(5);
base->Fun(5.00);
base->G();
return 0;
}
输出结果
分析:
1. 定义一个基类Base,基类内部有两个重载函数Fun和一个虚函数G
2. 子类SubClass继承了基类Base,子类首先隐藏了基类的两个函数Fun并且覆盖了基类虚函数G;
如果基类函数是虚函数,那么子类重新定义就属于覆盖。
如果基类函数不是虚函数,那么子类重新定义属于隐藏基类函数
3. main函数内部,基类指针base指向子类对象指针subClass,然后调用三个函数
(1)base->Fun(5) 输出“Base::Fun(int x)”说明调用的是基类的函数,可以看出通过基类指针并不能动态的调用子类覆盖基类的非虚函数
(2)base->Fun(5.00) 和上面类似
(3)base->G() 输出"SubClass::G(void)" 说明调用的是子类的函数G,可以看出通过基类指针可以动态的调用子类覆盖基类的虚函数
由此可见,多态的实现是通过子类覆盖基类的虚函数,利用基类指针指向不同的子类对象,在运行的时候动态的决定要调用哪个子类虚函数。
C++编程语言是一款应用广泛,支持多种程序设计的计算机编程语言。我们今天就会为大家详细介绍其中C++多态性的一些基本知识,以方便大家在学习过程中对此能够有一个充分的掌握。
多态性可以简单地概括为“一个接口,多种方法”,程序在运行时才决定调用的函数,它是面向对象编程领域的核心概念。多态(polymorphisn),字面意思多种形状。
C++多态性是通过虚函数来实现的,虚函数允许子类重新定义成员函数,而子类重新定义父类的做法称为覆盖(override),或者称为重写。(这里我觉得要补充,重写的话可以有两种,直接重写成员函数和重写虚函数,只有重写了虚函数的才能算作是体现了C++多态性)而重载则是允许有多个同名的函数,而这些函数的参数列表不同,允许参数个数不同,参数类型不同,或者两者都不同。编译器会根据这些函数的不同列表,将同名的函数的名称做修饰,从而生成一些不同名称的预处理函数,来实现同名函数调用时的重载问题。但这并没有体现多态性。
多态与非多态的实质区别就是函数地址是早绑定还是晚绑定。如果函数的调用,在编译器编译期间就可以确定函数的调用地址,并生产代码,是静态的,就是说地址是早绑定的。而如果函数调用的地址不能在编译器期间确定,需要在运行时才确定,这就属于晚绑定。
那么多态的作用是什么呢,封装可以使得代码模块化,继承可以扩展已存在的代码,他们的目的都是为了代码重用。而多态的目的则是为了接口重用。也就是说,不论传递过来的究竟是那个类的对象,函数都能够通过同一个接口调用到适应各自对象的实现方法。
最常见的用法就是声明基类的指针,利用该指针指向任意一个子类对象,调用相应的虚函数,可以根据指向的子类的不同而实现不同的方法。如果没有使用虚函数的话,即没有利用C++多态性,则利用基类指针调用相应的函数的时候,将总被限制在基类函数本身,而无法调用到子类中被重写过的函数。因为没有多态性,函数调用的地址将是一定的,而固定的地址将始终调用到同一个函数,这就无法实现一个接口,多种方法的目的了。
笔试题目:
[cpp] view
plaincopy
#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;
}
第一个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()函数的地址,因此调用了基类的函数。由此可见多态性的强大,可以适应各种变化,不论指针是基类的还是子类的,都能找到正确的实现方法。
[cpp] view
plaincopy
//小结: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),而不是覆盖。
me:重载是发生在同作用域中,见C++primer第四版,p500
另可参见http://blog.csdn.net/Last_Time/article/details/4812520关于重载,覆盖,隐藏的概念
-----------------------------------下面是一个覆盖与隐藏的例子-------------------
[cpp] view
plaincopy
#include<iostream>
class a{
public:
virtual void print(){
std::cout<<"NULL print in a"<<std::endl;
}
virtual void print(
e097
int){
std::cout<<"int print in a"<<std::endl;
}
};
class b:public a{
public:
virtual void print(){//can hide print ,print(int) in a
std::cout<<"NULL print in b"<<std::endl;
}
};
class c:public b{
public:
virtual void print(int){//can hide print in b,a
std::cout<<"int print in c"<<std::endl;
}
};
int main(){
b b1;
b1.print();
//b1.print(1);//compile error,hide
c c1;
c1.print(1);
//c1.print();//compile error,hide
//虚函数被隐藏,但是还是可以通过指针访问到,如果不是虚函数,当然通过指针也不能
a*ap=new c;
ap->print(1);//int print in c
}
~
1. 重载指的是函数具有的不同的参数列表,而函数名相同的函数。重载要求参数列表必须不同,比如参数的类型不同、参数的个数不同、参数的顺序不同。
2. 如果仅仅是函数的返回值不同是没办法重载的,因为重载要求参数列表必须不同。
3. 程序是根据参数列表来确定具体要调用哪个函数的
4. 看下面几个例子
void Fun(int a);
void Fun(double a);
void Fun(int a, int b);
void Fun(double a, int b);
上面四个函数都可以构成函数重载
int Fun(int a)
void Fun(int a)
//上面两个是无法构成函数重载的,参数列表必须不同
二. 覆盖(重写override)
1. 覆盖是存在类中,子类重写从基类继承过来的函数。但是函数名、返回值、参数列表都必须和基类相同。
2. 当子类的对象调用成员函数的时候,如果成员函数有被覆盖则调用子类中覆盖的版本,否则调用从基类继承过来的函数
3. 如果子类覆盖的是基类的虚函数,可以用来实现多态。
当子类重新定义基类的虚函数之后,基类指针可以根据赋给它不同子类指针动态的调用子类中的虚函数,可以做到动态绑定,这就是多态。
4. 子类覆盖基类函数的特征
(1)函数名相同、参数相同、返回值相同
(2)如果基类函数是虚函数,子类覆盖虚函数可以实现多态
三. 重载和覆盖的区别
1. 重载要求函数名相同,但是参数列表必须不同,返回值可以相同也可以不同。
覆盖要求函数名、参数列表、返回值必须相同。
2. 在类中重载是同一个类中不同成员函数之间的关系
在类中覆盖则是子类和基类之间不同成员函数之间的关系
3. 重载函数的调用是根据参数列表来决定调用哪一个函数
覆盖函数的调用是根据对象类型的不同决定调用哪一个
4. 在类中对成员函数重载是不能够实现多态
在子类中对基类虚函数的覆盖可以实现多态
看下面这个例子
[cpp]
4000
view
plain copy
#include<iostream>
#include<algorithm>
using namespace std;
//基类
class Base{
public:
//基类Fun为重载函数
void Fun(int x){
cout<<"Base::Fun(int x)"<<endl;
}
void Fun(double x){
cout<<"Base::Fun(double x)"<<endl;
}
//基类虚函数
virtual void G(void){
cout<<"Base::G(void)"<<endl;
}
};
//子类
class SubClass:public Base{
public:
//隐藏基类的Fun函数
void Fun(int x){
cout<<"SubClass::Fun(int x)"<<endl;
}
void Fun(double x){
cout<<"SubClass::Fun(double x)"<<endl;
}
//覆盖基类虚函数
virtual void G(void){
cout<<"SubClass::G(void)"<<endl;
}
};
int main(){
Base *base = new Base();
SubClass *subClass = new SubClass();
base = subClass; //基类指针指向子类对象
//测试函数调用
base->Fun(5);
base->Fun(5.00);
base->G();
return 0;
}
输出结果
分析:
1. 定义一个基类Base,基类内部有两个重载函数Fun和一个虚函数G
2. 子类SubClass继承了基类Base,子类首先隐藏了基类的两个函数Fun并且覆盖了基类虚函数G;
如果基类函数是虚函数,那么子类重新定义就属于覆盖。
如果基类函数不是虚函数,那么子类重新定义属于隐藏基类函数
3. main函数内部,基类指针base指向子类对象指针subClass,然后调用三个函数
(1)base->Fun(5) 输出“Base::Fun(int x)”说明调用的是基类的函数,可以看出通过基类指针并不能动态的调用子类覆盖基类的非虚函数
(2)base->Fun(5.00) 和上面类似
(3)base->G() 输出"SubClass::G(void)" 说明调用的是子类的函数G,可以看出通过基类指针可以动态的调用子类覆盖基类的虚函数
由此可见,多态的实现是通过子类覆盖基类的虚函数,利用基类指针指向不同的子类对象,在运行的时候动态的决定要调用哪个子类虚函数。
一. 重载(overload)
1. 重载指的是函数具有的不同的参数列表,而函数名相同的函数。重载要求参数列表必须不同,比如参数的类型不同、参数的个数不同、参数的顺序不同。
2. 如果仅仅是函数的返回值不同是没办法重载的,因为重载要求参数列表必须不同。
3. 程序是根据参数列表来确定具体要调用哪个函数的
4. 看下面几个例子
void Fun(int a);
void Fun(double a);
void Fun(int a, int b);
void Fun(double a, int b);
上面四个函数都可以构成函数重载
int Fun(int a)
void Fun(int a)
//上面两个是无法构成函数重载的,参数列表必须不同
二. 覆盖(重写override)
1. 覆盖是存在类中,子类重写从基类继承过来的函数。但是函数名、返回值、参数列表都必须和基类相同。
2. 当子类的对象调用成员函数的时候,如果成员函数有被覆盖则调用子类中覆盖的版本,否则调用从基类继承过来的函数
3. 如果子类覆盖的是基类的虚函数,可以用来实现多态。
当子类重新定义基类的虚函数之后,基类指针可以根据赋给它不同子类指针动态的调用子类中的虚函数,可以做到动态绑定,这就是多态。
4. 子类覆盖基类函数的特征
(1)函数名相同、参数相同、返回值相同
(2)如果基类函数是虚函数,子类覆盖虚函数可以实现多态
三. 重载和覆盖的区别
1. 重载要求函数名相同,但是参数列表必须不同,返回值可以相同也可以不同。
覆盖要求函数名、参数列表、返回值必须相同。
2. 在类中重载是同一个类中不同成员函数之间的关系
在类中覆盖则是子类和基类之间不同成员函数之间的关系
3. 重载函数的调用是根据参数列表来决定调用哪一个函数
覆盖函数的调用是根据对象类型的不同决定调用哪一个
4. 在类中对成员函数重载是不能够实现多态
在子类中对基类虚函数的覆盖可以实现多态
看下面这个例子
[cpp] view
plain copy
#include<iostream>
#include<algorithm>
using namespace std;
//基类
class Base{
public:
//基类Fun为重载函数
void Fun(int x){
cout<<"Base::Fun(int x)"<<endl;
}
void Fun(double x){
cout<<"Base::Fun(double x)"<<endl;
}
//基类虚函数
virtual void G(void){
cout<<"Base::G(void)"<<endl;
}
};
//子类
class SubClass:public Base{
public:
//隐藏基类的Fun函数
void Fun(int x){
cout<<"SubClass::Fun(int x)"<<endl;
}
void Fun(double x){
cout<<"SubClass::Fun(double x)"<<endl;
}
//覆盖基类虚函数
virtual void G(void){
cout<<"SubClass::G(void)"<<endl;
}
};
int main(){
Base *base = new Base();
SubClass *subClass = new SubClass();
base = subClass; //基类指针指向子类对象
//测试函数调用
base->Fun(5);
base->Fun(5.00);
base->G();
return 0;
}
输出结果
分析:
1. 定义一个基类Base,基类内部有两个重载函数Fun和一个虚函数G
2. 子类SubClass继承了基类Base,子类首先隐藏了基类的两个函数Fun并且覆盖了基类虚函数G;
如果基类函数是虚函数,那么子类重新定义就属于覆盖。
如果基类函数不是虚函数,那么子类重新定义属于隐藏基类函数
3. main函数内部,基类指针base指向子类对象指针subClass,然后调用三个函数
(1)base->Fun(5) 输出“Base::Fun(int x)”说明调用的是基类的函数,可以看出通过基类指针并不能动态的调用子类覆盖基类的非虚函数
(2)base->Fun(5.00) 和上面类似
(3)base->G() 输出"SubClass::G(void)" 说明调用的是子类的函数G,可以看出通过基类指针可以动态的调用子类覆盖基类的虚函数
由此可见,多态的实现是通过子类覆盖基类的虚函数,利用基类指针指向不同的子类对象,在运行的时候动态的决定要调用哪个子类虚函数。
C++学习之多态及重载(overload),覆盖(override),隐藏(hide)的区别
C++编程语言是一款应用广泛,支持多种程序设计的计算机编程语言。我们今天就会为大家详细介绍其中C++多态性的一些基本知识,以方便大家在学习过程中对此能够有一个充分的掌握。多态性可以简单地概括为“一个接口,多种方法”,程序在运行时才决定调用的函数,它是面向对象编程领域的核心概念。多态(polymorphisn),字面意思多种形状。
C++多态性是通过虚函数来实现的,虚函数允许子类重新定义成员函数,而子类重新定义父类的做法称为覆盖(override),或者称为重写。(这里我觉得要补充,重写的话可以有两种,直接重写成员函数和重写虚函数,只有重写了虚函数的才能算作是体现了C++多态性)而重载则是允许有多个同名的函数,而这些函数的参数列表不同,允许参数个数不同,参数类型不同,或者两者都不同。编译器会根据这些函数的不同列表,将同名的函数的名称做修饰,从而生成一些不同名称的预处理函数,来实现同名函数调用时的重载问题。但这并没有体现多态性。
多态与非多态的实质区别就是函数地址是早绑定还是晚绑定。如果函数的调用,在编译器编译期间就可以确定函数的调用地址,并生产代码,是静态的,就是说地址是早绑定的。而如果函数调用的地址不能在编译器期间确定,需要在运行时才确定,这就属于晚绑定。
那么多态的作用是什么呢,封装可以使得代码模块化,继承可以扩展已存在的代码,他们的目的都是为了代码重用。而多态的目的则是为了接口重用。也就是说,不论传递过来的究竟是那个类的对象,函数都能够通过同一个接口调用到适应各自对象的实现方法。
最常见的用法就是声明基类的指针,利用该指针指向任意一个子类对象,调用相应的虚函数,可以根据指向的子类的不同而实现不同的方法。如果没有使用虚函数的话,即没有利用C++多态性,则利用基类指针调用相应的函数的时候,将总被限制在基类函数本身,而无法调用到子类中被重写过的函数。因为没有多态性,函数调用的地址将是一定的,而固定的地址将始终调用到同一个函数,这就无法实现一个接口,多种方法的目的了。
笔试题目:
[cpp] view
plaincopy
#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;
}
第一个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()函数的地址,因此调用了基类的函数。由此可见多态性的强大,可以适应各种变化,不论指针是基类的还是子类的,都能找到正确的实现方法。
[cpp] view
plaincopy
//小结: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),而不是覆盖。
me:重载是发生在同作用域中,见C++primer第四版,p500
另可参见http://blog.csdn.net/Last_Time/article/details/4812520关于重载,覆盖,隐藏的概念
-----------------------------------下面是一个覆盖与隐藏的例子-------------------
[cpp] view
plaincopy
#include<iostream>
class a{
public:
virtual void print(){
std::cout<<"NULL print in a"<<std::endl;
}
virtual void print(
e097
int){
std::cout<<"int print in a"<<std::endl;
}
};
class b:public a{
public:
virtual void print(){//can hide print ,print(int) in a
std::cout<<"NULL print in b"<<std::endl;
}
};
class c:public b{
public:
virtual void print(int){//can hide print in b,a
std::cout<<"int print in c"<<std::endl;
}
};
int main(){
b b1;
b1.print();
//b1.print(1);//compile error,hide
c c1;
c1.print(1);
//c1.print();//compile error,hide
//虚函数被隐藏,但是还是可以通过指针访问到,如果不是虚函数,当然通过指针也不能
a*ap=new c;
ap->print(1);//int print in c
}
~
相关文章推荐
- C++中重载、重写(覆盖)和隐藏的区别实例分析
- C++函数覆盖,重载,隐藏的区别
- C++中覆盖、重载、隐藏的区别(写给菜鸟们)
- c++ 重载 覆盖 隐藏的区别和执行方式
- C++学习之多态及重载(overload),覆盖(override),隐藏(hide)的区别
- C++重载,覆盖, 隐藏三者的主要区别
- C++重载、覆盖、隐藏的区别与举例
- c++ 重载 覆盖 隐藏的区别和执行方式
- C++覆盖、重载、多态区别 ; 重载、重写(覆盖)、重定义(隐藏)三者区别
- [转]C++中重载(overload)、覆盖(override)、隐藏(hide)的区别
- 转载:c++重载、覆盖、隐藏——理不清的区别
- C++重载、覆盖和隐藏的区别
- C++中重载、覆盖与隐藏的区别(转)
- C++中重载、重写(覆盖)和隐藏的区别实例分析
- C++中函数覆盖 隐藏 重载区别
- c++ 重载 覆盖 隐藏的区别和执行方式
- c++ 重载 覆盖 隐藏的区别和执行方式
- C++函数的重载、覆盖和隐藏区别
- C++中重载、重写(覆盖)和隐藏的区别实例分析
- 【转】c++重载、覆盖、隐藏——理不清的区别