覆盖:
在基类中定义了一个非虚拟函数,然后在派生类中又定义了一个同名同参数同返回类型的函数,这就是覆盖了。
在派生类对象上直接调用这个函数名,只会调用派生类中的那个。
//coverage.cpp
#include <iostream>
using namespace std;
class A
{
public:
void ShowMessage();
};
class B:public A
{
public:
void ShowMessage();
};
void A::ShowMessage()
{
cout<<"Hello,This is A./n";
return;
}
void B::ShowMessage()
{
cout<<"Hello,This is B./n";
return;
}
int main()
{
A* p;
B memb;
*p = memb;
p->ShowMessage();
memb.ShowMessage();
return 0;
}
输出为:
Hello,This is A.
Hello,This is B.
重载:
有两个或多个函数名相同的函数,但是函数的形参列表不同。在调用相同函数名的函数时,根据形参列表确定到底该调用哪一个函数。
//reload
#include <iostream>
using namespace std;
class A
{
public:
void ShowMessage();
void ShowMessage(string str);
};
void A::ShowMessage()
{
cout<<"Hi,This is A./n";
return;
}
void A::ShowMessage(string str)
{
cout<<str<<endl;
return;
}
int main()
{
A mem;
mem.ShowMessage();
mem.ShowMessage("Hello.How are you?/n");
return 0;
}
输出为:
Hi,This is A.
Hello.How are you?
多态:
在基类中定义了一个虚拟函数,然后在派生类中又定义一个同名,同参数表的函数,这就是多态。多态是这3种情况中唯一采用动态绑定技术的一种情况。也就是说,通过一个基类指针来操作对象,如果对象是基类对象,就会调用基类中的那个函数,如果对象实际是派生类对象,就会调用派声雷中的那个函数,调用哪个函数并不由函数的参数表决定,而是由函数的实际类型决定。
//poly.cpp
#include <iostream>
using namespace std;
class A
{
public:
virtual void ShowMessage();
};
class B:public A
{
public:
void ShowMessage();
};
void A::ShowMessage()
{
cout<<"This is A./n";
return;
}
void B::ShowMessage()
{
cout<<"This is B./n";
return;
}
int main()
{
A* p;
p=new A();
p->ShowMessage();
p=new B();
p->ShowMessage();
return 0;
}
输出为:
This is A.
This is B.
----------------------------------------------------------------------------------------------------------------------------
1、重载
首先说重载,它最简单,C++中的重载和java中的差不多,都是在一个类中,方法名相同而参数不同的几个方法,但是不能靠返回类型来判断。例如:
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
上面的两个方法就属于重载。
2、重定义
重定义 (redefining)也叫做隐藏:
子类重新定义父类中有相同名称的非虚函数 ( 参数列表可以不同 ) 。
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
这种情况下print()和print(int x)叫作重定义,在重定义时,父类的print()方法被隐藏了,要想使用父类的方法必须通过::。
3、重写(也叫覆盖)
函数特征相同。但是具体实现不同,主要是在继承关系中出现的 。当我们对别人提供好的类的方法感觉不是太满意时,我们就可以通过继承这个类然后重写其方法改成我们需要的逻辑。
1、最重要的一点,重写是子类与父类之间的。
2、被重写的函数不能是 static 的。
3、函数三要素(函数名、函数参数、函数返回类型)完全一样
4、如果父类中有virtual关键字,这种父子之间的关系叫做虚函数重写,这也就是C++中的多态机制,和java自动转换不同的是,C++需要我们手动设置。
例如:
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
这个输出结果取决于AA类中的void print(int x )函数前面是否加入virtual关键字,如果加了则调用子类的,否则父类。