多态是在不同继承关系的类对象,去调用同一函数,产生了不同的行为。比如Student继承了
Person。Person对象买票全价,Student对象买票半价
class Person {
public:
virtual void BuyTicket() { cout << "买票-全价" << endl; }
};
class Student : public Person {
public:
virtual void BuyTicket() { cout << "买票-半价" << endl; }
/*注意:在重写基类虚函数时,派生类的虚函数在不加virtual关键字时,虽然也可以构成重写(因
为继承后基类的虚函数被继承下来了在派生类依旧保持虚函数属性),但是该种写法不是很规范,不建议
这样使用*/
/*void BuyTicket() { cout << "买票-半价" << endl; }*/
};
void Func(Person& p)
//虚函数重写的两个例外:
//1. 协变(基类与派生类虚函数返回值类型不同)
//派生类重写基类虚函数时,与基类虚函数返回值类型不同。即基类虚函数返回基类对象的指
//针或者引用,派生类虚函数返回派生类对象的指针或者引用时,称为协变。(了解)
//2. 析构函数的重写(基类与派生类析构函数的名字不同)
//如果基类的析构函数为虚函数,此时派生类析构函数只要定义,无论是否加virtual关键字,
//都与基类的析构函数构成重写,虽然基类与派生类析构函数名字不同。虽然函数名不相同,
//看起来违背了重写的规则,其实不然,这里可以理解为编译器对析构函数的名称做了特殊处
//理,编译后析构函数的名称统一处理成destructor。
{
p.BuyTicket();
}
int main()
{
Person ps;
Student st;
Func(ps);
Func(st);
return 0;
}
原理图
普通继承是子类继承父类的全部,是一种复用。
虚函数在多态情况下是子类复用父类的接口,重写父类的实现。
多态条件![](https://i-blog.csdnimg.cn/blog_migrate/f8d01f631a286d2f3517a3f2c53ae6bd.png)
举例(ps:下面就是通过修改多态的条件从而不满足多态)
void Func(Person p)
{
p.BuyTicket();
}
要求三同,假设我们这里让参数不同:
class Person {
public:
virtual void BuyTicket() { cout << "买票-全价" << endl; }
};
class Student : public Person {
public:
virtual void BuyTicket(int ) { cout << "买票-半价" << endl; }
};
重写虚函数
Person* p=new Person;
delete p;
p = new Student;
delete p;
我们发现子类的析构函数没有被正确调用。
这是因为delete是根据指针类型来调用的。
但是person指针可能指向person,也可能指向student。
它的调用如下:先调用destrutor函数再调用析构函数。 destrutor是普通函数,普通函数调用看类型,因为是person指针类型,所以调用person析构。
我们不希望它是普通继承,因为如果是普通继承就不会调子类析构,会造成内存泄漏。
那我们怎么样让它变多态呢?第一:三同(参数相同,函数名相同,返回值相同)二:虚函数重写
~Person() ~Student()参数没有,返回值没有,函数名不同,但是为了满足多态进行了特殊处理。
现在只差虚函数重写这一项了,我们给析构加上virtual:
virtual ~Person()
{
cout << "~Person()" << endl;
}
};
virtual ~Student()
{
cout << "~Student()" << endl;
}
练习题
说出如下代码打印结果:
class Person
{
public:
virtual void func(int a = 1) { cout << "A->" << a << endl; }
virtual void test() { func(); }
};
class Student: public Person
{
void func(int a = 0) {cout << "B->" << a << endl;}
};
int main()
{
Student* B=new Student;
B->test();
return 0;
}
结果:
B->1
解析:
那如果是这样呢?我不访问test(),我直接访问func*()
class Person
{
public:
virtual void func(int a = 1) { cout << "A->" << a << endl; }
virtual void test() { func(); }
};
class Student: public Person
{
public:
void func(int a = 0) {cout << "B->" << a << endl;}
};
int main()
{
Student* B=new Student;
B->func();
return 0;
}
答案很明显,不构成多态,因为多态需要父类指针,而下面是子类的指针,不构成多台那就是普通的,普通的话就会隐藏,会访问子类的。
要想访问父类我们指定父类域就可以了:
#include <iostream>
using namespace std;
class Person
{
public:
virtual void func(int a = 1) { cout << "A->" << a << endl; }
virtual void test() { func(); }
};
class Student : public Person
{
public:
void func(int a = 0) {
Person::func(1); // 调用基类Person的func函数
cout << "B->" << a << endl;
}
};
int main()
{
Student* B = new Student;
B->Person::func();
return 0;
}
要想形成多态我们改为父类指针就行了:
class Person
{
public:
virtual void func(int a = 1) { cout << "A->" << a << endl; }
virtual void test() { func(); }
};
class Student: public Person
{
public:
void func(int a = 0) {cout << "B->" << a << endl;}
};
int main()
{
Person* B = new Person;
B=new Student;
B->func();
return 0;
}
抽象类
虚函数+“=0”就是纯虚函数包含纯虚函数的类就叫抽象类,抽象类不能实例化:
class A
{
public:
virtual void fun() = 0;
};
那抽象类要怎么才能实例化呢?不能实例化这个类就没有意义,实例化要通过虚函数重写:
如下,指针指向谁就访问谁
class A
{
public:
virtual void fun() = 0;
};
class B: public A
{
void fun()
{
cout << "B->舒适" << endl;
}
};
class C : public A
{
void fun()
{
cout << "B->巴适" << endl;
}
};
void fun(A* p)
{
p->fun();
}
int main()
{
fun(new B);
fun(new C);
return 0;
}
虚函数表
如下代码求出来的字节大小为多少:
class Person {
public:
virtual void BuyTicket() { cout << "买票-全价" << endl; }
};
class Student : public Person {
public:
void BuyTicket() { cout << "买票-半价" << endl; }
private:
int _a;
};
int main()
{
cout << sizeof(Student) << endl;
return 0;
}
答案:
原因,只要有虚函数,大小就要把多算一个虚函数指针的大小,如果没有虚函数,那它的大小就为它的成员int_a的大小,就是4:
虚函数指针存放在 虚函数表里面。虚函数表我们称为vf
ptr(virtaul function ptr table ),而vfptr在代码段里存放着。
现在在子类中再加个char _b成员变量,然后在64位操作系统下运行,此刻的大小为多少呢?
class Person {
public:
virtual void BuyTicket() { cout << "买票-全价" << endl; }
};
class Student : public Person {
public:
void BuyTicket() { cout << "买票-半价" << endl; }
private:
int _a;
char _b;
};
int main()
{
Student b;
cout << sizeof(Student) << endl;
return 0;
}
答案:
因为64位操作系统按8进行内存对齐。
如下,如果fun1,fun2是虚函数,fun3不是虚函数,那么fun3就不在vfptr里面。
虚函数实际上在代码段里面,只是把地址放在vfptr里面而已。
class Student : public Person {
public:
virtual void fun1() { cout << "fun1()" << endl; }
virtual void fun2(){ cout << "fun2()" << endl; }
void fun3(){ cout << "fun3()" << endl; }
};
int main()
{
Student b;
return 0;
}
多态是怎么来的
观察下面地址和代码,我们发现子类只是把父类的BuyTicket()函数重写了,func()函数没有重写,还是同一个func()。
class Person {
public:
virtual void BuyTicket() { cout << "买票-全价" << endl; }
virtual void fun(){}
};
class Student : public Person {
public:
virtual void BuyTicket() { cout << "买票-半价" << endl; }
};
void Func(Person& p)
{
p.BuyTicket();
}
int main()
{
Person ps;
Student st;
Func(ps);
Func(st);
return 0;
}
调用BuyTick()函数的时候它也不知道调父类的BuyTick()函数还是子类的BuyTick()函数,但是它会去调vfptr,如果调父类就通过虚函数表去调父类的BuyTick(),如果调子类就对父类的vfptr切片,仍然通过vfptr调BuyTick(),不过此时BuyTick()已经是子类的BuyTick()了。