"也应该歌颂赞美那株鲜红的玫瑰。"
一、回顾多态
(1)什么是多态呢
在编程语言和类型轮中,多态(英语:polymorphism)指为不同数据类型的实体提供统一的接口。多态类型(英语:polymorphic type)可以将自身所支持的操作套用到其它类型的值上。 取自这里
所谓多态,通俗来讲就是多种形态。当不同的对象去执行同一个行为,产生处不同的结果和状态。我们举一个买车票的例子,普通人买车票 对应的是"全价",学生呢买车票则对应的是"半价",军人买票呢,对应的是"优先买票"。
(2)多态的定义
多态形成的条件:
①虚函数完成重写
②父类的指针或者引用去调用虚函数
虚函数;
什么是虚函数呢?C++定义了一个关键字virtual,这个肯定不陌生,因为在前篇谈论虚继承的时候,这位仁兄出现过,展现出了它惊人的一面。
virtual void func(){}
虚函数的重写(覆盖)要求:
派生类中有一个跟基类完全相同的虚函数(即派生类虚函数与基类虚函数的返回值类型、函数名字、参数列表完全相同)
我们根据上述的场景,简单来实现一份多态的代码吧~
class Person
{
public:
virtual void BuyTicket() { cout << "Person--买票-全价" << endl; }
};
class Student :public Person
{
virtual void BuyTicket() { cout << "Student -- 买票-半价" << endl; }
};
class Soidler :public Person
{
virtual void BuyTicket() { cout << "Soidler -- 买票-军人优先" << endl; }
};
此时还不是多态。因为我们都知道,那个对象就调用哪个对象的类成员方法。我们还差一个条件,"父类的指针引用去调用虚函数"。
显然,颠覆我们的认知。不管是student、soidler、person都传递给父类引用,但是因为多态的条件达成,那么传递的什么类型,就去调用什么类型中被重写(覆盖)。
(3)override\final
继承final:
如果你不想让一个类被继承,那么你应该让它的构造函数声明为私有;
这是C++11之期解决类不能被继承的写法。C++11后引入了final关键字表示该类不能被继承。
虚函数final:
final:修饰虚函数,表示该虚函数不能再被重写。
overrid
检查派生类虚函数是否重写了基类某个虚函数,如果没有重写编译报错
二、多态与析构函数
在继承中,我们层提到,在子类的析构函数中,不用显式去调用父类的析构函数,因为当子类的析构函数结束后,就会去调用父类的析构函数。
我们来看看下面的一段代码;
class Person
{
public:
~Person()
{
cout << "Person delete:" << _p << endl;
delete[] _p;
}
protected:
int* _p = new int[10];
};
class Student : public Person
{
public:
~Student()
{
cout << "Student delete:" << _s << endl;
delete[] _s;
}
protected:
int* _s = new int[20];
};
int main()
{
Person* ptr1 = new Person;
Person* ptr2 = new Student;
delete ptr1;
delete ptr2;
return 0;
}
delete类,要做两件事:调用释放类的析构函数,再调用operator.delete()。
我们析构ptr1那么很好,它成功地帮我释放了Person中的数组。delete ptr2时,它仅仅帮我们完成了父类的析构函数。难道你会指着编译器抱怨,不去释放那子类对象动态开辟的空间,而造成的内存泄漏的问题?当然不行!这怨不得人家,因为它严格按照,自己是什么类,就去调用该类的拥有的什么成员方法。
似乎我们预想的是,让ptr2delete的时候,不是去调用它类型的析构,而是去调用new的对Student的析构。看到这里我们想到了什么??? 父类的指针引用调用重写的虚函数构成多态!
class Person
{
public:
//虚函数
virtual ~Person()
{
cout << "Person delete:" << _p << endl;
delete[] _p;
}
protected:
int* _p = new int[10];
};
class Student : public Person
{
public:
//虚函数
virtual ~Student()
{
cout << "Student delete:" << _s << endl;
delete[] _s;
}
protected:
int* _s = new int[20];
};
同时,这里也回答了上一篇中,为什么在编译器看来基类与派生类的析构函数,都会做特殊处理成一样的函数(destructor)。就是为了 实现多态的析构函数。
请记住:
"为多态基类声明virtual析构函数"。这是永远不会错的。
三、sizeof(Base)
我们看看下面的代码,你能否计算该类的大小?
class A
{
public:
void Func(){}
private:
int _a;
char _b;
};
内存对齐!这可难不到我,_a占4字节,_b占1字节,内存对齐到8。A的大小为8byte。
嗯?还不错,确实是8字节。
class A
{
public:
virtual void Func(){}
private:
int _a;
char _b;
};
这难道不是同一道题?这么送分的嘛?
这怎么回事儿?为什么加上虚函数,类的大小就变了呢?
这个是因为,当类有虚函数时,就会给类增加一个结构,"虚函数表指针"。那么这个虚函数表指针的讲解不在本篇,也就此略过。
四、抽象类
在虚函数的后面写上 =0 ,则这个函数为纯虚函数。
包含纯虚函数的类叫做抽象类(也叫接口类),抽象类不能实例化出对象。
同时,这也要求了,该基类的派生类必须完成重写,否则无任何意义。
class Car
{
public:
//纯虚函数
virtual void Drive() = 0;
};
class BMW : public Car
{
public:
};
int main()
{
BMW b;
return 0;
}
class Car
{
public:
//纯虚函数
virtual void Drive() = 0;
};
class BMW : public Car
{
public:
virtual void Drive()
{
cout << "驾驶乐趣" << endl;
}
};
int main()
{
BMW b;
return 0;
}
接口继承vs实现继承:
普通函数的继承是一种实现继承,派生类继承了基类函数,可以使用函数,继承的是函数的实现。
虚函数的继承是一种接口继承,派生类继承的是基类虚函数的接口,目的是为了重写,达成多态,继承的是接口。
五、经典考察
我们最后以一道面试题作为本篇的结束。
class A
{
public:
virtual void func(int val = 1){ std::cout << "A->" << val << std::endl; }
void test() { func(); }
};
class B : public A
{
public:
virtual void func(int val = 0){ std::cout << "B->" << val << std::endl; }
};
int main(int argc, char* argv[])
{
B*p = new B;
p->test();
return 0;
}
程序应该打印成什么?
最后也就是这个结果。
总结:
①final+类 该类不可被继承。final+函数该函数不可被重写。 overrid编译时检查子类虚函数重写。
②记住,在多态基类最好实现成虚函数。
③包含纯虚函数的类是抽象类,纯虚函数就是在虚函数 =0。
本篇也就在这里告一段落,感谢你的阅读。
祝你好运~向阳而生。