第18课 - 继承与多态 - 下
问：
重载和重写有什么区别？什么时候是重载，什么时候是重写？
1. 重载与重写
下面程序的继承方式有问题吗，为什么？
#include <cstdlib>
#include <iostream>
using namespace std;
class Parent
{
public:
virtual void func()
{
cout<<"void func()"<<endl;
}
virtual void func(int i)
{
cout<<"void func(int i)"<<endl;
}
virtual void func(int i, int j)
{
cout<<"void func(int i, int j)"<<endl;
}
//三个func函数在这个结构体中是函数的重载 ，又是三个虚函数
};
class Child : public Parent
{
public:
void func(int i, int j) /*只要在父类中声明了virtual，子类中就自动为virtual，写不写一样*/
{
cout<<"void func(int i, int j)"<<" "<<i + j<<endl;
}
void func(int i, int j, int k) //这个函数与父类中的func函数不是重载
{
cout<<"void func(int i, int j, int k)"<<" "<<i + j + k<<endl;
}
};
void run(Parent* p)
{
p->func(1, 2);
}
int main(int argc, char *argv[])
{
Parent p;
p.func();
p.func(1);
p.func(1, 2);
Child c;
c.func(1, 2);
run(&p);
run(&c);
cout << "Press the enter key to continue ...";
cin.get();
return EXIT_SUCCESS;
}
运行结果：
void func()
void func(int i)
void func(int i, int j)
void func(int i, int j) 3
void func(int i, int j)
void func(int i, int j) 3
子类里面的同名函数是无法重载父类里面的同名函数的。要是得具体区分使用某个函数的话，就要使用作用域分辨符。重载对于一个函数来说，只能存在于一个类中，或者说同一个作用域之中。发生在两个作用域中的叫做重写。
函数重载
必须在同一个类中进行。
子类无法重载父类的函数，父类同名函数将被覆盖。
重载是在编译期间根据参数类型和个数决定调用函数。
函数重写
必须发生于父类与子类之间。
并且父类与子类中的函数必须有完全相同的原型。
使用virtual声明之后能够产生多态。
多态是在运行期间根据具体对象的类型决定调用函数。
问题
是否可以将类的每个成员函数都声明为虚函数？
2. 虚函数深入理解
C++中多态的实现原理
当类中声明虚函数时，编译器会在类中生成一个虚函数表。
虚函数表是一个存储类成员函数指针的数据结构。
虚函数表是由编译器自动生成与维护的。
virtual成员函数会被编译器放入虚函数表中。
存在虚函数时，每个对象中都有一个指向虚函数表的指针。
VPTR是C++自动生成的指针，用来指向virtual函数的函数表。这个指针会被C++定义为第一个数据成员。
通过虚函数表指针VPTR调用重写函数是在程序运行时进行的，因此需要通过寻址操作才能确定真正应该调用的函数。而普通成员函数是在编译时就确定了调用的函数。在效率上，虚函数的效率要低很多。出于效率考虑，没有必要将所有成员函数都声明为虚函数。
问：
对象中的VPTR指针什么时候被初始化？
答：
对象在创建的时候由编译器对VPTR指针进行初始化。
只有当对象的构造完全结束后VPTR的指向才最终确定。
父类对象的VPTR指向父类虚函数表。
子类对象的VPTR指向子类虚函数表。
结论：
构造函数中调用虚函数无法实现多态。
3. 手把手写程序-构造函数中的“多态”
#include <cstdlib>
#include <iostream>
using namespace std;
class Parent
{
public:
Parent()
{
this->func();
}
virtual void func()
{
cout<<"void Parent::func()"<<endl;
}
};
class Child : public Parent
{
public:
void func() //也是虚函数
{
cout<<"void Child::func()"<<endl;
}
};
int main(int argc, char *argv[])
{
Child c;
cout << "Press the enter key to continue ...";
cin.get();
return EXIT_SUCCESS;
}
运行结果：
void Parent::func()
这里直接打印了父类的函数。子类重写了func函数，这里面并没有产生多态。我们在生成这个child对象的时候，率先调用了父类的构造函数。在调用构造函数之前会调用VPTR指针，这个指针指向了父函数的虚函数表(parent::VTABLE)。接下来执行父类的构造函数。this指针指向了当前对象func函数。func是虚函数，我们就到虚函数表里面去找。这时候我们发现，VPTR指向的是父类的parent::VTABLE。所以会打印父类的func函数。调用了父类的构造函数，接下来就会去调用子类的构造函数（由C++默认提供）。将要调用子类的构造函数，VPTR此时指向的是child::VTABLE。
4. 纯虚函数
在进行面向对象分析时，会有一些抽象的概念！
在现实中需要知道具体的图形类型才能求面积，所以对概念上的“图形”求面积是没有意义的！
class Shape
{
public:
double area()
{
return 0;
}
};
这个类的设计完全脱离实际，没有任何的意义！
用Shape作为基类进行继承
#include <cstdlib>
#include <iostream>
using namespace std;
class Shape
{
public:
virtual double area() = 0;
};
class Rectangle : public Shape
{
double m_a;
double m_b;
public:
Rectangle(double a, double b)
{
m_a = a;
m_b = b;
}
double area()
{
return m_a * m_b;
}
};
class Circle : public Shape
{
double m_r;
public:
Circle(double r)
{
m_r = r;
}
double area()
{
return 3.14 * m_r * m_r;
}
};
void area(Shape* s)
{
cout<<s->area()<<endl;
}
int main(int argc, char *argv[])
{
Rectangle rect(2, 3);
Circle circle(4);
area(&rect);
area(&circle);
cout << "Press the enter key to continue ...";
cin.get();
return EXIT_SUCCESS;
}
运行结果：
6
50.24
面向对象中的抽象类
抽象类可用于表示现实世界中的抽象概念。
抽象类是一种只能定义类型，而不能产生对象的类。
抽象类只能被继承并重写相关函数。
抽象类的直接特征是纯虚函数。
纯虚函数是只声明函数原型，而故意不定义函数体的虚函数。
抽象类与纯虚函数
抽象类不能用于定义对象。
抽象类只能用于定义指针和引用。
抽象中的纯虚函数必须被子类重写。
class Shape
{
public:
virtual double area() = 0;
};
area是纯虚函数，= 0 告诉编译器，这个函数故意只声明不定义。
小结：
函数重载与函数重写不同。
多态是通过虚函数表实现的。
虚函数在效率上会受到影响。
抽象类可用于表示现实世界中的抽象概念。
抽象类是通过纯虚函数实现的。