目录
1,什么是多态?
多态是指同样的消息被不同类型的对象界首市导致的不同行为,所谓小学时只对类的成员函数调用,不同的行为是指不同的实现,也就是调用了不同的函数。多态性提供接口与具体实现之间的另一层隔离,同时创建了使程序具有扩展性。事实上在程序设计中经常使用多态,的特性,最近简单的例子就是运算符对不同类型的数据对象运算。
多态的类型一般分为两类:
静态多态(编译时多态,早绑定):函数重载、运算符重载、重定义
动态多态(运行时多态,晚绑定):虚函数 父类指针(引用)保存 子类空间地址的目的 就是让算法通用。
2,什么是虚函数?
1.如何实现父类对各个派生子类的操作?
这里的操作是在继承父类成员的条件下,对子类继承的成员的操作,也就是调用
首先要实现父类对各个派生子类的操作,我们需要父类指针保存子类空间,利用这个方式实现父类算法通用。
总结:通过构建父类指针保存子类的空间,实现对各个子类的操作(实际上这里还并不行,但这是实现该功能的前提)!
在这个基础上,构建虚函数或者纯虚函数他才会成立,在主函数中有应当如何去调用,都是父类指针保存子类空间的这个前提!!
2,父类指针保存子类空间产生的问题。
我们的目的是需要操作各个子类,虽然实现了如何访问哥哥派生子类,但实际上还并未能操作子类。
例:
#include<iostream>
using namespace std;
class animal
{
public:
void nameshow()
{
cout << "我是什么动物" << endl;
}
};
class cat :public animal
{
public:
void nameshow()
{
cout << "我是猫" << endl;
}
};
int main()
{
//通过父类指针保存子类空间,实现对各个派生类的操作
animal* p = new cat;
//但我们这里想要调用的是子类的成员,但结果是父类的成员
p->nameshow();
return 0;
}
由上例知道,通过父类指针保存子类空间是没问题的,但因为你是父类指针,调用时不是操作子类,而是父类,故还并未实现父类对子类的操作,此时我们在定义父类成员(一般为函数)时就添加了关键词virtual,也就是虚函数,引入虚函数,我们可以实现父类对子类的调用。
3,虚函数的定义
父类成员函数前加virtual修饰。
#include<iostream>
using namespace std;
class animal
{
public:
virtual void nameshow()
{
cout << "我是什么动物" << endl;
}
};
class cat :public animal
{
public:
void nameshow()
{
cout << "我是猫" << endl;
}
};
class dog :public animal
{
public:
void nameshow()
{
cout << "我是狗" << endl;
}
};
int main()
{
//通过父类指针保存子类空间,实现对各个派生类的操作
animal* p1 = new cat;
animal* p2 = new dog;
//成功调用
p1->nameshow();
p2->nameshow();
return 0;
}
通过关键词virtual我们将成员函数定义为虚函数,此时父类指针指向子类空间时,我们调用的就是子类的这个成员函数。
多态条件:有继承、子类重写父类的虚函数,父类指针 指向子类空间。
我们可将子类继承父类的成员当做链接父类与子类的桥梁,父类指针指向各个子类空间就是实现各个桥梁,virtual就是实现父类通过桥梁到子类。
4,虚函数的动态绑定机制
当类中的成员函数被virtual修饰,那么这个函数就是虚函数,并且就会产生一个虚函数指针,指向了一张虚函数表(vftable),如果这个函数没有涉及到继承,这时虚函数表中记录着当前虚函数入口地址。
此时子类如dog:
可以看到子类会把父类的虚函数指针继承过来,同时把虚函数表继承过来,但虚函数表会被重写,可以看到上图中的表发生了改变,此时入口地址也发生了改变,此时调用时因为索引(地址)发生了改变,故调用的是子类的中的成员函数。
5,重载,重定义,重写的区别
重载:同一作用域,同名函数,参数的顺序、个数、类型不同 都可以重载。函数的返回值类型不能作为 重载条件(函数重载、运算符重载)。
重定义:有继承,子类 重定义 父类的同名函数(非虚函数), 参数顺序、个数、类型可以不同。子类 的同名函数会屏蔽父类的所有同名函数(可以通过作用域解决)。
重写(覆盖):有继承,子类 重写 父类的虚函数。返回值类型、函数名、参数顺序、个数、类型都必须 一致。
3,纯虚函数
我们可以发现如果基类一定派生出子类,而子类一定会重写父类的虚函数,也就是子类函数有自己的功能,那么父类的虚函数中的函数体感觉是无意义(我们既不需要调用它,在设计时他也是一个一个模糊的函数),那么可不可以不写父类虚函数的函数体呢?当然是可以的,而这就是纯虚函数。
纯虚函数的定义方式:
class 父类名
{
public:
//纯虚函数
virtual void speak(void)=0;
};
我们以一个实现对各个形状面积的计算的纯虚函数来实现。
include<iostream>
using namespace std;
class Shape
{
public:
//定义纯虚函数
virtual double Getarea(void)=0;
//也可以定义虚函数virtual double Getarea(void){return 0;}
void print()
{
cout<<"调用基类对象的成员函数"<<endl;
}
};
class Rectangle:public Shape
{
public:
void print()
{
cout<<"调用派生类对象(Rectangle)的成员函数"<<endl;
}
Rectangle(double x,double y)
{
Length=x;
Width=y;
}
double Getarea()
{
return Length*Width;
}
private:
double Length,Width;
};
class Circle:public Shape
{
public:
void print()
{
cout<<"调用派生类对象(Circle)的成员函数"<<endl;
}
Circle(double x)
{
Radious=x;
}
double Getarea()
{
return 3.14*Radious*Radious;
}
private:
double Radious;
};
int main()
{
Shape *p1=new Rectangle (2.2,2.0);
Shape *p2=new Circle (1.0);
cout<<"矩形面积为"<<p1->Getarea()<<endl;
cout<<"圆面积为:"<<p2->Getarea()<<endl;
return 0;
}
有纯虚函数的类我们称作抽象类,对于抽象类是无法实例化对象的。
这里shape a;就会报错,已经无法实现实例化对象。
虚函数和纯虚函数的区别:
虚函数:virtual修饰 有函数体 不会导致父类为抽象类。
纯虚函数:virtual修饰,=0,没有函数体 导致父类为抽象类。子类必须重写父类的所有纯虚函数。
4,虚析构函数
顾名思义,就是虚函数的析构函数。
因为之前我们在上例中都是用new开辟一个子类的空间,我们是在堆区上开辟的,若不释放就会造成内存泄漏。
如这里的animal*p=new cat;
delete p;
而在这里释放时直接delete这个父类指针,但是我们存放的是子类的空间,却是父类类型,故释放的应该是子类中属于父类的这一部分空间,但事实上我们new的是整个子类空间,因此在析构时只会调用父类中的析构,与子类无关,因此释放不彻底,有部分内存存在泄漏的可能。
那么如何去释放父类指针中的所有空间,这时候我们还是添加virtual,实现对父类指针中子类空间的全部释放,这就是虚析构。此时调用就会父类与子类的析构都会调用。
#include<iostream>
using namespace std;
class animal
{
public:
animal()
{
cout << "调用父类构造" << endl;
}
virtual void nameshow()
{
cout << "我是什么动物" << endl;
}
~animal()//virtual ~animal()
{
cout << "调用父类析构" << endl;
}
};
class cat :public animal
{
public:
cat()
{
cout << "调用cat构造" << endl;
}
void nameshow()
{
cout << "我是猫" << endl;
}
~cat()
{
cout << "调用cat析构" << endl;
}
};
class dog :public animal
{
public:
dog()
{
cout << "调用dog构造" << endl;
}
void nameshow()
{
cout << "我是狗" << endl;
}
~dog()
{
cout << "调用dog析构" << endl;
}
};
int main()
{
//通过父类指针保存子类空间,实现对各个派生类的操作
animal* p1 = new cat;
animal* p2 = new dog;
//但我们这里想要调用的是子类的成员,但结果是父类的成员
p1->nameshow();
p2->nameshow();
//释放空间,调用析构
delete p1;
delete p2;
return 0;
}
这里未调用子类析构,可知这一部分空间未被删除,添加关键字virtual后:
可以发现父类保存的子类空间全部被释放掉。
1,纯虚构函数
纯虚析构函数的定义:
纯虚析构的本质:是析构函数,各个类的回收工作。而且析构函数不能被继承, 必须为纯虚析构函数提供一个函数体。(而纯虚函数是没有函数体的)
纯虚析构函数: 必须在类外实现.
例:
class animal
{
public:
animal()
{
cout << "调用父类构造" << endl;
}
virtual void nameshow()
{
cout << "我是什么动物" << endl;
}
//纯虚析构函数
virtual ~animal(void) = 0;
};
animal::~animal()
{
cout << "调用父类析构" << endl;
}
class cat :public animal
{
public:
cat()
{
cout << "调用cat构造" << endl;
}
void nameshow()
{
cout << "我是猫" << endl;
}
~cat()
{
cout << "调用cat析构" << endl;
}
};
class dog :public animal
{
public:
dog()
{
cout << "调用dog构造" << endl;
}
void nameshow()
{
cout << "我是狗" << endl;
}
~dog()
{
cout << "调用dog析构" << endl;
}
};
int main()
{
//通过父类指针保存子类空间,实现对各个派生类的操作
animal* p1 = new cat;
animal* p2 = new dog;
//但我们这里想要调用的是子类的成员,但结果是父类的成员
p1->nameshow();
p2->nameshow();
//释放空间,调用析构
delete p1;
delete p2;
return 0;
}
这样的书写方式就是纯虚析构函数的实现,作用与上述虚析构函数的作用相同,两者都释放了父类和子类的空间,析构也都调用了。
2,虚析构和纯虚析构的区别
虚析构:virtual修饰,有函数体,不会导致父类为抽象类。
纯虚析构:virtual修饰,=0,函数体必须类外实现,导致父类为抽象类