8.1 虚函数
8.1.1 虚函数的声明与定义
需要借助关键字 virtual关键字实现
格式：
class 类名
{
public：
virtual 函数返回值类型 函数名(参数列表); //只需要在函数的声明前加，表示声明该函数为虚函数
}
以该类派生出的派生类，派生类重定义父类的虚函数的时候，即使不加virtual 关键字，此时在子类中该函数也是虚函数，以它的子类为基类继续派生出新的派生类重定义虚方法，在新的派生类中也是虚函数
派生类重定义父类的虚方法需要满足一定的格式，才能在派生类中也是虚函数
1）派生类中需要与基类的资源同名，有相同的函数名
2）与基类有相同的参数列表（参数的个数，参数的位置，参数的类型）
3）与基类需要有相同的函数返回值类型
如果基类返回值类型为基类的指针或者是基类的引用，则在派生类中，派生类中虚函数返回值类型为派生类的指针或者派生的类引用
8.1.2 虚函数的用法
1）类型适应 ，函数的参数传递实现多样化，派生类适应基类，丧失多态性
2）虚函数 ， 使用基类的指针或者基类的引用访问同名资源时候，不取决于基类的类型而是由类型指针指向的对象的类型或者引用引用目标的类型决定访问是哪个函数实体，
3）基类的指针，基类的引用
8.2 虚函数的访问
对虚函数的访问方式不同，程序具体调用哪个函数可能也会有所不同
8.2.1 对象名访问
通过对象访问虚函数还是非虚函数，由对象本身的类型决定，----》采用静态联编的形式
#include <iostream>
using namespace std;
class Base { public: void show(){cout << "Base 类show函数"<<endl;} //在函数的声明前加 virtual int fun(int x){cout << "Base 类fun函数" <<endl;return x ;} virtual void test(){cout << "Base类的 test函数"<<endl;} };
class Child:public Base { public: void show(){cout << "Child 类show函数"<<endl;} //即使不加virtual关键字，该函数仍然是虚函数 int fun(int x){cout << "Child 类fun函数" <<endl;return x ;} };
class grandChild:public Child { public: void show(){cout << "grandChild 类show函数"<<endl;} //仍然是虚函数 int fun(int x){cout << "grandChild 类fun函数" <<endl;return x ;} void test(){cout << "grandChild类的 test函数"<<endl;} };
int main() { Child ch; Base base; grandChild grand;
base = ch; base.show(); base.fun(10);
base = grand; base.show(); base.fun(10);
ch = grand; ch.show(); ch.fun(10); //派生类对象赋值给基类对象， //无论是调用非虚函数还是虚函数，调用都是基类的函数 } |
8.2.2 指针访问
指针访问的是非虚函数，由指针本身的类型（定义时指针指向的对象的类型）决定访问的是哪个函数
指针访问的是虚函数，则由实际上指针指向的对象的类型决定，而不是定义指针指针指向的对象的类型
int main() { Child ch,*pch; Base *base; grandChild grand;
base = &ch; //派生类对象赋值给基类指针 base->show(); //基类指针访问非虚函数 base->fun(10);//基类指针访问虚函数
cout << "========================="<<endl;
base = &grand; base->show(); //基类指针访问非虚函数 base->fun(10);//基类指针访问虚函数
cout << "========================="<<endl; pch = &grand; pch->show();//基类指针访问非虚函数 pch->fun(20); //基类指针访问非虚函数 } |
8.2.3 引用访问
引用的本质是指针，引用访问非虚函数和虚函数的访问方法一样
引用一旦初始化之后，则引用的对象就固定不可改变，后期对引用进行赋值不能改变引用的对象
引用访问虚函数，由实际上引用的引用对象的类型决定
引用访问的是非虚函数，则由引用本身的类型决定
int main() { Child ch; grandChild grand;
Base &base = ch; //基类hase的引用对象是派生类ch对象 base.show(); //引用访问非虚函数 base.fun(10);//引用访问虚函数
cout << "========================="<<endl;
base = grand; //对引用赋值 base.show(); //引用访问非虚函数 base.fun(10); //引用访问虚函数
cout << "========================="<<endl; Child &pch = grand; // pch.show(); //引用访问非虚函数 pch.fun(20);//引用访问虚函数
pch = ch; pch.show(); //引用访问非虚函数 pch.fun(20);//引用访问虚函数 } |
8.2.4 类内访问
在类的成员函数内部访问，成员函数内部有this指针，分清this 指针本身类型（成员函数所在的类型）
this指针实际上指向的对象的类型
-------à指针访问虚函数和非虚函数
#include <iostream>
using namespace std;
class Base { public: void show(){cout << "Base 类show函数"<<endl;} virtual void fun(){cout << "Base 类fun函数" <<endl;} void base_1() { //this 指针本身类型：Base this->show(); this->fun(); cout << "Base 类base_1函数" <<endl; } void base_2() { Base::show(); Base::fun(); cout << "Base 类base_2函数" <<endl; } };
class Child:public Base { public: void show(){cout << "Child 类show函数"<<endl;} //即使不加virtual关键字，该函数仍然是虚函数 void fun(){cout << "Child 类fun函数" <<endl;} };
int main() { Child ch; Base base;
ch.base_1(); ch.base_2(); cout << "===============" << endl; base.base_1(); base.base_2(); cout << "===============" << endl; base = ch; base.base_1(); base.base_2() } |
8.2.5 在构造函数或析构函数中访问
在构造函数和析构函数中访问虚函数和非虚函数，实际上采用静态联编的形式，由自己本类的类型决定
在哪个类中则访问的是哪个类的虚函数和非虚函数
#include <iostream>
using namespace std;
class Base { public: void show(){cout << "Base 类show函数"<<endl;} virtual void fun(){cout << "Base 类fun函数" <<endl;} Base(){show(); fun(); cout << "Base类型的构造函数" <<endl;} ~Base(){show(); fun(); cout << "Base类型的析构函数" <<endl;} }; class Child:public Base { public: void show(){cout << "Child 类show函数"<<endl;} void fun(){cout << "Child 类fun函数" <<endl;} Child():Base(){show(); fun(); cout << "Child类型的构造函数" <<endl;} ~Child(){show(); fun(); cout << "Child类型的析构函数" <<endl;} }; int main() { Child ch;
} |
将派生的类型对象赋值给基类的指针或者基类的引用，访问虚函数，由引用或者指针实际上指向的对象的类型决定