定义:方法的行为取决于调用该方法的对象,就是随着上下文,同一种方法具有不同的形态。称为多态。
调用同一个函数,编译器会根据上下文,匹配不同的形态。
#include <iostream>
using namespace std;
class Shape{
public:
virtual double getL(void){
}
};
class Cir:public Shape{
public:
Cir(int ri):r(ri){ };
double getL(void){
return 3.14*r*2;
}
private:
int r;
};
class Tir:public Shape{
public:
Tir(int a,int b, int c ):e1(a),e2(b),e3(c){
}
double getL(void){
return e1+e2+e3;
}
private:
int e1;
int e2;
int e3;
};
class Ret:public Shape{
public:
Ret(int a,int b):h(a),w(b){
}
double getL(void){
return 2*(h+w);
}
private:
int h;
int w;
};
double totalL(Shape *arr[],int n){
double sum = 0;
for(int i =0;i<n;++i){
sum += arr[i]->getL();
}
return sum;
}
int main (){
Cir C(4);
Tir T(3,4,5);
Ret R(5,8);
Shape *arr[] = {&C,&T,&R};
cout << totalL(arr,3) << endl;
}
虚函数: 关键字 virtual .
虚函数的作用:在基类中使用虚函数,这样如果派生类中有和这个函数同名的函数,就会覆盖虚函数。
这样就可以避免。
在C++中,基类的指针可以指向派生类的地址。
当你用一个基类指针指向派生类的对象时,你想对派生类的对象调用派生类的方法的时候,会调用基类的方法。
EG:
当:virtual double getL(void) = 0;
时称为纯虚函数。
但它为一个纯虚函数的时候,你如果条用了它就会报错。
比如:我的
class Shape{
public:
virtual double getL(void){
}
但是我图形就是,模糊的东西,我的代码,中就可以出现调用,Shape.getL这种操作。
但是,重编译器的角度来讲,Shape.getL,这是没有问题的,但是你把它声明成纯虚函数。
你再调用Shape.getL,编译器就会报错。
虚函数,避免内存泄漏的问题。
#include <iostream>
using namespace std;
class A {
public:
A(){
cout << "++++++++++A" << endl;
}
~A(){
cout << "~~~~~~~~A" << endl;
}
void show(){
cout << "-----------A" << endl;
}
};
class Ax:public A{
public:
Ax(){
cout << "++++++++++A" << endl;
}
~Ax(){
cout << "~~~~~~~~AX" << endl;
}
void show(){
cout << "************AX" << endl;
}
};
int main (){
A *p =new Ax;
delete p;
}
我们再调用了,构造派生类的时候,它会调用基类的构造函数。
再析构的时候,它会调用基类和派生类的析构函数。
但是,像上面的情况,由于我的指针是基类的,然后在delete的时候就会值调用基类的析构,就少析构了派生类。
这样就会造成内存泄漏。
为避免这种情况,以及上面的情况,建议在构建基类的时候,使用虚函数。virtual