4、多态
问题引出（赋值兼容性原则遇上函数重写）
面向对象新需求
C++提供的多态解决方案
多态案例
多态工程意义
面向对象三大概念、三种境界（封装、继承、多态）
多态成立条件
总结条件、看代码的时候要看出多态
4.1多态
4.1.1问题引出
如果子类定义了与父类中原型相同的函数会发生什么？
//demo_13类型兼容性原则遇上函数重写.cpp
#include <iostream>
using namespace std;
class Parent
{
public:
Parent(int a)
{
this->a = a;
cout << "Parent a " << a << endl;
}
void print()
{
cout << "Parent 打印 a" << a << endl;
}
private:
int a;
};
class Child:public Parent
{
public:
//当父类的构造函数有参数时，需要在子类的初始化列表中显示调用
Child(int b) :Parent(10)
{
this->b = b;
cout << "Child b" << b << endl;
}
void print()
{
cout << "Child 打印 b" << b << endl;
}
private:
int b;
};
/*
兼容规则中所指的替代包括以下情况：
子类对象可以当作父类对象使用
子类对象可以直接赋值给父类对象
子类对象可以直接初始化父类对象
父类指针可以直接指向子类对象
父类引用可以直接引用子类对象
*/
//父类指针做函数参数
void HowToPrint(Parent *base)
{
base->print();
}
//父类引用做函数参数
void HowToPrint01(Parent &base)
{
base.print();
}
void main()
{
Parent *base = NULL;
Parent p1(20);
Child c1(30);
base = &p1;
base->print();//调用父类的打印函数
//父类指针可以直接指向子类对象
base = &c1;
base->print();//执行谁的函数 ? //面向对象新需求 //调用父类的打印函数
//父类引用可以直接引用子类对象
Parent &base1 = p1;
base1.print();//调用父类的打印函数
Parent &base2 = c1;
base2.print();//调用父类的打印函数
//父类指针做函数参数
HowToPrint(&p1);//调用父类的打印函数
HowToPrint(&c1);//调用父类的打印函数
//父类引用做函数参数
HowToPrint01(p1);//调用父类的打印函数
HowToPrint01(c1);//调用父类的打印函数
cout << "hello..." << endl;
system("pause");
return;
}//demo_14C++提供的多态解决方案.cpp
#include <iostream>
using namespace std;
class Parent
{
public:
Parent(int a)
{
this->a = a;
cout << "Parent a " << a << endl;
}
virtual void print()//子类的和父类的函数名字一样
{
cout << "Parent 打印 a" << a << endl;
}
private:
int a;
};
class Child :public Parent
{
public:
//当父类的构造函数有参数时，需要在子类的初始化列表中显示调用
Child(int b) :Parent(10)
{
this->b = b;
cout << "Child b" << b << endl;
}
//virtual 父类写了virtual,子类可写 可不写 一般都会写，让人觉得显目，知道这里要用多态了
virtual void print()
{
cout << "Child 打印 b" << b << endl;
}
private:
int b;
};
/*
兼容规则中所指的替代包括以下情况：
子类对象可以当作父类对象使用
子类对象可以直接赋值给父类对象
子类对象可以直接初始化父类对象
父类指针可以直接指向子类对象
父类引用可以直接引用子类对象
*/
//父类指针做函数参数
void HowToPrint(Parent *base)
{
base->print();
}
//父类引用做函数参数
void HowToPrint01(Parent &base)
{
base.print();
}
void main()
{
Parent *base = NULL;
Parent p1(20);
Child c1(30);
base = &p1;
base->print();//调用父类的打印函数
//父类指针可以直接指向子类对象
base = &c1;
base->print();//执行谁的函数 ? //面向对象新需求 //调用父类的打印函数
//父类引用可以直接引用子类对象
Parent &base1 = p1;
base1.print();//调用父类的打印函数
Parent &base2 = c1;
base2.print();//调用父类的打印函数
//父类指针做函数参数
HowToPrint(&p1);//调用父类的打印函数
HowToPrint(&c1);//调用父类的打印函数
//父类引用做函数参数
HowToPrint01(p1);//调用父类的打印函数
HowToPrint01(c1);//调用父类的打印函数
cout << "hello..." << endl;
system("pause");
return;
}4.1.2面向对象新需求
编译器的做法不是我们期望的
根据实际的对象类型来判断重写函数的调用
如果父类指针指向的是父类对象则调用父类中定义的函数
如果父类指针指向的是子类对象则调用子类中定义的重写函数
4.1.3解决方案
Ø C++中通过virtual关键字对多态进行支持
Ø 使用virtual声明的函数被重写后即可展现多态特性
4.1.4多态实例
#include <iostream>
using namespace std;
//不写virtual关键字 是静态联编 C++编译器根据HeroFighter类型,去执行 这个类型的power函数 在编译器编译阶段就已经决定了函数的调用
//动态联编: 迟绑定: //在运行的时候,根据具体对象(具体的类型),执行不同对象的函数 ,表现成多态.
class Hero
{
public:
virtual int power()
{
return 25;
}
};
//1.要有继承关系
class AdvHero:public Hero
{
public:
//2.要有虚函数重写
virtual int power()//C++会对这个函数特殊处理
{
return 156;
}
};
class EnemyFighter
{
public:
virtual int attack()
{
return 50;
}
};
//多态威力
//1 PlayObj给对象搭建舞台 看成一个框架
//
class AdvEnemy :public EnemyFighter
{
public:
virtual int attack()
{
return 1150;
}
};
//父类指针做函数参数
void playObj(Hero *h1, EnemyFighter *ef1)
{
if (h1->power() > ef1->attack())
{
printf("Hero Win\n");
}else{
printf("Hero Lose\n");
}
}
//父类引用做函数参数
void playObj01(Hero &h1, EnemyFighter &ef1)
{
if (h1.power() > ef1.attack())
{
printf("Hero Win\n");
}
else{
printf("Hero Lose\n");
}
}
/*
多态的思想
面向对象的三大概念
封装:突破c函数的概念 用类做函数参数的时候，可以使用对象的属性和对象的方法
继承：A B代码复用
多态：可以使用未来...
多态很重要
实现多态的三个条件
C语言 间接赋值 是指针存在的最大意义
是C语言的特有现象（1.定义两个变量 2. 建立关联 3. *p在被调用函数中去间接的修改实参的值）
引用：（1.定义两个变量 2. 建立关联 把前两步合作成一步，作为原变量的别名 3. &p在被调用函数中去间接的修改实参的值）
实现多态的三个条件：
1.要有继承关系
2.要有虚函数重写
3.用父类指针（父类引用）指向子类对象
*/
void main()
{
Hero h1;
AdvHero Ah1;
EnemyFighter ef1;
AdvEnemy Advef1;
//3.用父类指针（父类引用）指向子类对象
//父类指针做函数参数
playObj(&h1,&ef1);
playObj(&Ah1, &ef1);
//父类引用做函数参数
playObj01(h1, ef1);
playObj01(Ah1, ef1);
//未来在加一个超级敌战机
{
//父类指针做函数参数
playObj(&h1, &Advef1);
playObj(&Ah1, &Advef1);
//父类引用做函数参数
playObj01(h1, Advef1);
playObj01(Ah1, Advef1);
}
system("pause");
}
void main1501()
{
Hero h1;
AdvHero Ah1;
EnemyFighter ef1;
if (h1.power() > ef1.attack())
{
printf("Hero Win\n");
}
else
{
printf("Hero Lose\n");
}
if (Ah1.power() > ef1.attack())
{
printf("Hero Win\n");
}
else
{
printf("Hero Lose\n");
}
}4.1.5多态工程意义
//面向对象3大概念
/*
封装
突破了C语言函数的概念。。
继承
代码复用。。。。我复用原来写好的代码。。。
多态
多态可以使用未来。。。。。80年代写了一个框架。。。。。。90人写的代码
多态是我们软件行业追寻的一个目标。。。
//写了一个框架，可以调用后来人，写的代码的能力
*/
4.1.6多态成立的条件
//间接赋值成立的3个条件
//1 定义两个变量。。。
//2 建立关联。。。。
//3 *p
//多态成立的三个条件
//1 要有继承
//2 要有函数重写。。。C 虚函数
//3 要有父类指针（父类引用）指向子类对象
//多态是设计模式的基础，多态是框架的基础
4.1.7多态的理论基础
01静态联编和动态联编
1、联编是指一个程序模块、代码之间互相关联的过程。
2、静态联编（staticbinding），是程序的匹配、连接在编译阶段实现，也称为早期匹配。
重载函数使用静态联编。
3、动态联编是指程序联编推迟到运行时进行，所以又称为晚期联编（迟绑定）。
switch 语句和 if 语句是动态联编的例子。
4、理论联系实际
1、C++与C相同，是静态编译型语言 2、在编译时，编译器自动根据指针的类型判断指向的是一个什么样的对象；所以编译器认为父类指针指向的是父类对象。 3、由于程序没有运行，所以不可能知道父类指针指向的具体是父类对象还是子类对象 从程序安全的角度，编译器假设父类指针只指向父类对象，因此编译的结果为调用父类的成员函数。这种特性就是静态联编。 |
4.2多态相关面试题
面试题1：请谈谈你对多态的理解
多态的实现效果 多态：同样的调用语句有多种不同的表现形态； 多态实现的三个条件 有继承、有virtual重写、有父类指针（引用）指向子类对象。 多态的C++实现 virtual关键字，告诉编译器这个函数要支持多态；不是根据指针类型判断如何调用；而是要根据指针所指向的实际对象类型来判断如何调用 动态联编PK静态联编。根据实际的对象类型来判断重写函数的调用。 多态的重要意义 设计模式的基础是框架的基石。 实现多态的理论基础 函数指针做函数参数 C函数指针是C++至高无上的荣耀。C函数指针一般有两种用法（正、反）。 多态原理探究 与面试官展开讨论 |
面试题2：谈谈C++编译器是如何实现多态
c++编译器多态实现原理
面试题3：谈谈你对重写，重载理解
函数重载
必须在同一个类中进行
子类无法重载父类的函数，父类同名函数将被名称覆盖
重载是在编译期间根据参数类型和个数决定函数调用
函数重写
必须发生于父类与子类之间
并且父类与子类中的函数必须有完全相同的原型
使用virtual声明之后能够产生多态(如果不使用virtual，那叫重定义)
多态是在运行期间根据具体对象的类型决定函数调用
#include <iostream>
using namespace std;
class Parent
{
public:
void abc()
{
printf("abc");
}
virtual void func()
{
cout << "func() do..." << endl;
}
virtual void func(int i)//重载必须在一个类之间
{
cout << "func() do..." << i << endl;
}
virtual void func(int i,int j)//重载必须在一个类之间
{
cout << "func() do..." << i << j <<endl;
}
private:
};
class Child:public Parent
{
public:
void abc()//重写发生在2个类之间
{
printf("Child abc");
}
virtual void func(int i, int j)//重写发生在2个类之间
{
cout << "func(int i, int j) do..." << i << " " << j << endl;
}
virtual void func(int i, int j,int k)
{
cout << "func(int i, int j) do..." << i << " " << j << k << endl;
}
private:
};
//重写 重载 重定义
//重写发生在2个类之间
//重载必须在一个类之间
//重写分为2类
//1 虚函数重写 将发生多态
//2 非虚函数重写 （重定义）
int main()
{
Child c1;
//子类无法重载父类的函数，父类同名函数将被名称覆盖
//1 C++编译器 看到func名字 ,因子类中func名字已经存在了(名称覆盖).所以c++编译器不会去找父类的4个参数的func函数
//2 c++编译器只会在子类中,查找func函数,找到了两个func,一个是2个参数的,一个是3个参数的.
//3 C++编译器开始报错..... error C2661: “Child::func”: 没有重载函数接受 0 个参数
//4 若想调用父类的func,只能加上父类的域名..这样去调用..
//c1.func();
c1.Parent::func();
c1.abc();
Parent &p1 = c1;
p1.abc();//父类指针（引用）指向子类对象，普通时候，不发生多态
Parent &p2 = c1;
p2.func(1,2);
system("pause");
return 0;
}#include <iostream>
using namespace std;
class Parent
{
public:
Parent(int a)
{
this->a = a;
}
void prinT()
{
cout << "Parent " << endl;
}
private:
int a;
};
class Parent1
{
public:
Parent1(int b)
{
this->b = b;
}
virtual void prinT()
{
cout << "Parent1 " << endl;
}
private:
int b;
};
int main()
{
cout << "sizeof(Parent):" << sizeof(Parent) << endl;//4
cout << "sizeof(Parent1):" << sizeof(Parent1) << endl;//16
//证明了当添加virtual,有vptr指针的存在
return 0;
}面试题4：是否可类的每个成员函数都声明为虚函数，为什么。 c++编译器多态实现原理
面试题5：构造函数中调用虚函数能实现多态吗？为什么？ c++编译器多态实现原理
面试题6：虚函数表指针（VPTR）被编译器初始化的过程，你是如何理解的？
c++编译器多态实现原理
面试题7：父类的构造函数中调用虚函数，能发生多态吗？ c++编译器多态实现原理
面试题8：为什么要定义虚析构函数？
在什么情况下应当声明虚函数
Ø 构造函数不能是虚函数。建立一个派生类对象时，必须从类层次的根开始，沿着继承路径逐个调用基类的构造函数
Ø 析构函数可以是虚的。虚析构函数用于指引 delete 运算符正确析构动态对象
其他
父类指针和子类指针的步长
1） 铁律1：指针也只一种数据类型，C++类对象的指针p++/--，仍然可用。
2） 指针运算是按照指针所指的类型进行的。
p++《=》p=p+1 //p = (unsigned int)basep + sizeof(*p) 步长。
3） 结论：父类p++与子类p++步长不同；不要混搭，不要用父类指针++方式操作数组。
4.3多态原理探究
理论知识：
Ø 当类中声明虚函数时，编译器会在类中生成一个虚函数表
Ø 虚函数表是一个存储类成员函数指针的数据结构
Ø 虚函数表是由编译器自动生成与维护的
Ø virtual成员函数会被编译器放入虚函数表中
Ø 当存在虚函数时，每个对象中都有一个指向虚函数表的指针（C++编译器给父类对象、子类对象提前布局vptr指针；当进行howToPrint(Parent *base)函数是，C++编译器不需要区分子类对象或者父类对象，只需要再base指针中，找vptr指针即可。）
Ø VPTR一般作为类对象的第一个成员
4.3.1多态的实现原理
C++中多态的实现原理 当类中声明虚函数时，编译器会在类中生成一个虚函数表 虚函数表是一个存储类成员函数指针的数据结构 虚函数表是由编译器自动生成与维护的 virtual成员函数会被编译器放入虚函数表中 存在虚函数时，每个对象中都有一个指向虚函数表的指针(vptr指针) |
|
说明1： 通过虚函数表指针VPTR调用重写函数是在程序运行时进行的，因此需要通过寻址操作才能确定真正应该调用的函数。而普通成员函数是在编译时就确定了调用的函数。在效率上，虚函数的效率要低很多。 说明2： 出于效率考虑，没有必要将所有成员函数都声明为虚函数 |
说明3 ：C++编译器，执行HowToPrint函数，不需要区分是子类对象还是父类对象
|
4.3.2如何证明vptr指针的存在
#include <iostream> using namespace std;
class A { public: void printf() { cout<<"aaa"<<endl; } protected: private: int a; };
class B { public: virtual void printf() { cout<<"aaa"<<endl; } protected: private: int a; };
void main() { //加上virtual关键字 c++编译器会增加一个指向虚函数表的指针。。。 printf("sizeof(a):%d, sizeof(b):%d \n", sizeof(A), sizeof(B)); cout<<"hello..."<<endl; system("pause"); return ; } |
4.3.3构造函数中能调用虚函数，实现多态吗
1）对象中的VPTR指针什么时候被初始化？
对象在创建的时,由编译器对VPTR指针进行初始化 只有当对象的构造完全结束后VPTR的指向才最终确定 父类对象的VPTR指向父类虚函数表 子类对象的VPTR指向子类虚函数表
|
2）分析过程 画图分析
|
#include <iostream>
using namespace std;
class Parent
{
public:
Parent(int a)
{
this->a = a;
}
virtual void print()
{
cout << "我是父类" << endl;
}
private:
int a;
};
class Child:public Parent
{
public:
Child(int b) :Parent(0)
{
this->b = b;
}
virtual void print()
{
cout << "我是子类" << endl;
}
private:
int b;
};
int main()
{
Parent *pP = NULL;
Child *pC = NULL;
Child array[] = { Child(1), Child(2), Child(3) };
pP = array;
pC = array;
pP->print();
pC->print();//多态发生
pP++;
pC++;
pP->print();//发生中断
//在执行'++'操作之后在进行操作，会出现中断；
/*
指针运算是按指针类型的长度进行计算的，父类和子类类型长度不同在进行 '++' 操作之后，
每个数组元素的长度是子类的长度，父类指针所指的位置并不是下个数组元素的开始位置。
不能再数组上使用多态
*/
pC->print();
return 0;
}
5、纯虚函数和抽象类
5.1基本概念
//demo_21纯虚函数抽象类的语法基础.cpp
#include <iostream>
using namespace std;
class Figure
{
public:
//阅读一个统一的界面(接口),让子类使用,让子类必须去实现
virtual void getArea() = 0;
private:
};
class Circle:public Figure
{
public:
Circle(int a, int b)
{
this->a = a;
this->b = b;
}
virtual void getArea()
{
cout << "Circle area:" << 3.14*a*b << endl;
}
private:
int a;
int b;
};
class Tri :public Figure
{
public:
Tri(int a, int b)
{
this->a = a;
this->b = b;
}
virtual void getArea()
{
cout << "Tri area:" << a*b/2 << endl;
}
private:
int a;
int b;
};
class Squre :public Figure
{
public:
Squre(int a, int b)
{
this->a = a;
this->b = b;
}
virtual void getArea()
{
cout << "Squre area:" << a*b << endl;
}
private:
int a;
int b;
};
void objplay(Figure *base)
{
base->getArea(); //会发生多态
}
int main()
{
//Figure f; //抽象类不能被实例化
Figure *base = NULL; //抽象类不能被实例化 但是可以声明抽象类的指针和引用
Circle c1(1,2);
Tri t1(3,4);
Squre s1(1,5);
objplay(&c1);
objplay(&t1);
objplay(&s1);
return 0;
} 5.2抽象类案例
/*
C++中没有接口的概念
C++中可以使用纯虚函数实现接口
接口类中只有函数原型定义，没有任何数据的定义。
*/
//demo_22抽象类在多继承的应用.cpp
#include <iostream>
using namespace std;
class Interface1
{
public:
virtual int add(int a, int b) = 0;
virtual void print() = 0;
private:
};
class Interface2
{
public:
virtual int multi(int a, int b) = 0;
virtual void print() = 0;
private:
};
class Parent
{
public:
int getA()
{
a = 0;
cout << "Parent:getA()已经执行" << endl;
return a;
}
private:
int a;
};
class Child:public Interface1,public Interface2,public Parent
{
public:
virtual int add(int a, int b)
{
cout << "Child:add()已经执行" << endl;
return a + b;
}
virtual void print()
{
cout << "Child:print()已经执行" << endl;
}
virtual int multi(int a, int b)
{
cout << "Child:multi()已经执行" << endl;
return a * b;
}
private:
};
int main()
{
Child c1;
c1.print();
Interface1 *Int1 = &c1;
Int1->add(1,2);
Int1->print();
Interface2 *Int2 = &c1;
Int2->multi(1,2);
Int2->print();
Parent *p1 = &c1;
p1->getA();
system("pause");
return 0;
}5.3抽象类在多继承中的应用
C++中没有Java中的接口概念，抽象类可以模拟Java中的接口类。（接口和协议）
5.3.1有关多继承的说明
工程上的多继承
被实际开发经验抛弃的多继承
工程开发中真正意义上的多继承是几乎不被使用的
多重继承带来的代码复杂性远多于其带来的便利
多重继承对代码维护性上的影响是灾难性的
在设计方法上，任何多继承都可以用单继承代替
多继承中的二义性和多继承不能解决的问题
5.3.2多继承的应用场景
绝大多数面向对象语言都不支持多继承
绝大多数面向对象语言都支持接口的概念
C++中没有接口的概念
C++中可以使用纯虚函数实现接口
接口类中只有函数原型定义，没有任何数据的定义。
实际工程经验证明
多重继承接口不会带来二义性和复杂性等问题
多重继承可以通过精心设计用单继承和接口来代替
接口类只是一个功能说明，而不是功能实现。
子类需要根据功能说明定义功能实现。
5.4抽象类知识点强化
/*
编写一个C++程序, 计算程序员( programmer )工资
1要求能计算出初级程序员( junior_programmer ) 中级程序员 ( mid_programmer )高级程序员( adv_programmer)的工资
2要求利用抽象类统一界面,方便程序的扩展, 比如:新增, 计算架构师 (architect ) 的工资
*/
5.5面向抽象类编程思想强化
理论知识
Ø 虚函数和多态性使成员函数根据调用对象的类型产生不同的动作
Ø 多态性特别适合于实现分层结构的软件系统，便于对问题抽象时 定义共性，实现时定义区别
Ø 面向抽象类编程（面向接口编程）是项目开发中重要技能之一。
#include <iostream>
using namespace std;
/*
编写一个C++程序, 计算程序员( programmer )工资
1 要求能计算出初级程序员( junior_programmer ) 中级程序员 ( mid_programmer )高级程序员( adv_programmer)的工资
2 要求利用抽象类统一界面,方便程序的扩展, 比如:新增, 计算 架构师 (architect ) 的工资
*/
class programmer
{
public:
virtual void getSal() = 0;
private:
};
class junior_programmer:public programmer
{
public:
junior_programmer(char *name, char *job, int sal)
{
this->name = name;
this->job = job;
this->sal = sal;
}
virtual void getSal()
{
cout << name << ":" << job << ":" << sal << endl;
}
private:
char *name;
char *job;
int sal;
};
class mid_programmer :public programmer
{
public:
mid_programmer(char *name, char *job, int sal)
{
this->name = name;
this->job = job;
this->sal = sal;
}
virtual void getSal()
{
cout << name << ":" << job << ":" << sal << endl;
}
private:
char *name;
char *job;
int sal;
};
class adv_programmer :public programmer
{
public:
adv_programmer(char *name, char *job, int sal)
{
this->name = name;
this->job = job;
this->sal = sal;
}
virtual void getSal()
{
cout << name << ":" << job << ":" << sal << endl;
}
private:
char *name;
char *job;
int sal;
};
//计算函数 简单的框架
void CalProSal(programmer *base)
{
base->getSal();
}
class architect :public programmer
{
public:
architect(char *name, char *job, int sal)
{
this->name = name;
this->job = job;
this->sal = sal;
}
virtual void getSal()
{
cout << name << ":" << job << ":" << sal << endl;
}
private:
char *name;
char *job;
int sal;
};
int main()
{
junior_programmer jp("小王","初级",4000);
mid_programmer mp("小张","中级",4500);
adv_programmer ap("小刘","高级",6000);
CalProSal(&jp);
CalProSal(&mp);
CalProSal(&ap);
architect at("小二","架构师",10000);
CalProSal(&at);
return 0;
}
2865
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
