3、继承和派生+4、多态+5、纯虚函数和抽象类

3.4多继承

3.4.1多继承的应用

多继承概念

Ø    一个类有多个直接基类的继承关系称为多继承

Ø    多继承声明语法

class  派生类名 : 访问控制 基类名1 ,  访问控制 基类名2 ,  … , 访问控制 基类名n

    {

         数据成员和成员函数声明

    }；

Ø    类 C 可以根据访问控制同时继承类 A 和类B 的成员，并添加

     自己的成员

多继承的派生类构造和访问

Ø  多个基类的派生类构造函数可以用初始式调用基类构造函数初始化数据成员

Ø  执行顺序与单继承构造函数情况类似。多个直接基类构造函数执行顺序取决于定义派生类时指定的各个继承基类的顺序。

Ø   一个派生类对象拥有多个直接或间接基类的成员。不同名成员访问不会出现二义性。如果不同的基类有同名成员，派生类对象访问时应该加以识别。

多继承简单应用

//dm09_多继承语法
#include using namespace std;class Base1
{
public:Base1(int b1){this->b1 = b1;}void printB1(){cout << "b1:" << b1 << endl;}
protected:
private:int  b1;
};class Base2
{
public:Base2(int b2){this->b2 = b2;}void printB2(){cout << "b2:" << b2 << endl;}
protected:
private:int  b2;
};class Child:public Base1,public Base2
{
public://初始化列表Child(int b1, int b2, int c) :Base1(b1), Base2(b2){this->c = c;cout << "多继承" << endl;}void printC(){cout << "c:" << c << endl;}
private:int c;
};void main()
{Child b1(1, 2, 3);b1.printC();b1.printB1();b1.printB2();cout << "hello..." << endl;system("pause");return;
}

3.4.2虚继承

  如果一个派生类从多个基类派生，而这些基类又有一个共同的基类，则在对该基类中声明的名字进行访问时，可能产生二义性

总结：

Ø    如果一个派生类从多个基类派生，而这些基类又有一个共同

     的基类，则在对该基类中声明的名字进行访问时，可能产生

     二义性

Ø    如果在多条继承路径上有一个公共的基类，那么在继承路径的某处

     汇合点，这个公共基类就会在派生类的对象中产生多个基类子对象

Ø    要使这个公共基类在派生类中只产生一个子对象，必须对这个基类

     声明为虚继承，使这个基类成为虚基类。

Ø    虚继承声明使用关键字           virtual

实验：注意增加virtual关键字后，构造函数调用的次数。

3.5继承总结

Ø  继承是面向对象程序设计实现软件重用的重要方法。程序员可以在已有基类的基础上定义新的派生类。

Ø   单继承的派生类只有一个基类。多继承的派生类有多个基类。

Ø   派生类对基类成员的访问由继承方式和成员性质决定。

Ø   创建派生类对象时，先调用基类构造函数初始化派生类中的基类成员。调用析构函数的次序和调用构造函数的次序相反。

Ø   C++提供虚继承机制，防止类继承关系中成员访问的二义性。

Ø   多继承提供了软件重用的强大功能，也增加了程序的复杂性。

//dm10_多继承的二义性
#include 
using namespace std;class A
{
public:int a;A(int a){this->a = a;cout << "A类的构造函数" << endl;}
private:};class B1 :virtual public A
{
public:int b1;B1(int b1) :A(0){this->b1 = b1;cout << "B1类的构造函数" << endl;}
private:};class B2 :virtual public A
{
public:int b2;B2(int b2) :A(0){this->b2 = b2;cout << "B2类的构造函数" << endl;}
private:};class C:public B1,public B2
{
public:int c;C(int c = 0) :A(0), B1(0), B2(0){this->c = c;cout << "c类的构造函数" << endl;}void printC(){cout << "a" << a << " " << "b1" << b1 << " " << "b2" << b2 << "c" << c << endl;}
private:};void main()
{C c1;c1.b1 = 100;c1.b2 = 200;c1.c = 300;//建立C类对象时候,A的构造函数被调用两次:一次由B1调用 另一次由B2调用 以初始化C类的对象中所包含的两个B类的子对象//这样在调用A类时候,c++编译器不知道从哪一条路径来的 就会产生二义性//c1.a = 500;//解决方案1//c1.B1::a = 500;//c1.B2::a = 200;//解决方案2//进行虚继承c1.printC();cout << "hello..." << endl;system("pause");return;
}

//dm11_多继承原理抛砖#include using namespace std;class B
{
public:B(){cout << "B构造函数执行\n";}int b;
protected:
private:};class B1 : virtual public B //12
{
public:int b1;};class B2 : public B //8
{
public:int b2;
};class C : public B1, public B2
{
public:int c;
};void main()
{cout << sizeof(B) << endl; //4cout << sizeof(B1) << endl; //12 //加上virtual以后 , C++编译器会在给变量偷偷增加属性cout << sizeof(B2) << endl;  //8system("pause");}void main1101()
{C  c1;c1.b1 = 100;c1.b2 = 200;c1.c = 300;//c1.b = 500; //继承的二义性 和 虚继承解决方案//c1.B1::b = 500;//c1.B2::b = 500;cout << "hello..." << endl;system("pause");return;
}class D1
{
public:int k;
protected:
private:
};class D2
{
public:int k;
protected:
private:};class E : public D1, public D2
{
public:
protected:
private:
};void main1202()
{E e1;e1.D1::k = 100;e1.D2::k = 200;system("pause");
}

4、多态

问题引出（赋值兼容性原则遇上函数重写）

         面向对象新需求

         C++提供的多态解决方案

         多态案例

         多态工程意义

                   面向对象三大概念、三种境界（封装、继承、多态）

        多态成立条件

                   总结条件、看代码的时候要看出多态

//dm13_类型兼容性原则遇上函数重写
#include 
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 void print() //virtual 父类写了virtual,子类可写 可不写  一般都会写，让人觉得显目，知道这里要用多态了{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);//1.子类对象可以当作父类对象使用,调用父类的成员函数base = &p1;base->print();//执行父类的打印函数base = &c1;base->print();//不加virtual关键字 调用父类的 加了之后调用子类的//面向对象的新需求//赋值兼容性原则 //1-1 基类指针 (引用) 指向 子类对象{Parent &base1 = p1;base1.print();Parent &base2 = c1;//c1的别名 不加virtual 还是调用父类的打印函数base2.print();}//1-2 指针做函数参数{howtoPrint(&p1);howtoPrint(&c1);howtoPrint01(p1);howtoPrint01(c1);}cout << "hello..." << endl;system("pause");return;
}
//加virtual关键字			
//Parent a20
//Parent a10
//Child b30//Parent 打印 a : 20
//Child 打印  b : 30
//Parent 打印 a : 20
//Child 打印  b : 30
//Parent 打印 a : 20
//Child 打印  b : 30
//Parent 打印 a : 20
//Child 打印  b : 30
//hello...
//请按任意键继续. . .//不加virtual关键字
//Parent a20
//Parent a10
//Child b30//Parent 打印 a : 20
//Parent 打印 a : 10
//Parent 打印 a : 20
//Parent 打印 a : 10
//Parent 打印 a : 20
//Parent 打印 a : 10
//Parent 打印 a : 20
//Parent 打印 a : 10
//hello...
//请按任意键继续. . .

4.1多态

4.1.1问题引出

如果子类定义了与父类中原型相同的函数会发生什么？

4.1.2面向对象新需求

编译器的做法不是我们期望的

         根据实际的对象类型来判断重写函数的调用

         如果父类指针指向的是父类对象则调用父类中定义的函数

         如果父类指针指向的是子类对象则调用子类中定义的重写函数

4.1.3解决方案

Ø  C++中通过virtual关键字对多态进行支持

Ø  使用virtual声明的函数被重写后即可展现多态特性

4.1.4多态实例

//dm14_多态案例
//多态的思想
//面向对象3大概念
//封装: 突破c函数的概念....用类做函数参数的时候,可以使用对象的属性 和对象的方法 
//继承: A B 代码复用
//多态 : 可以使用未来...//多态很重要
//实现多态的三个条件
//C语言 间接赋值 是指针存在的最大意义
//是c语言的特有的现象 (1 定义两个变量  2 建立关联  3 *p在被调用函数中去间接的修改实参的值)//实现多态的三个条件
//1 要有继承 
//2 要有虚函数重写
//3 用父类指针(父类引用)指向子类对象....#include 
using namespace std;class HeroFighter
{
public:virtual int power()//C++会对这个函数特殊处理{return 10;}private:};class EnemyFighter
{
public:int attack(){return 15;}
};class AdvHeroFighter:public HeroFighter//1 要有继承 
{
public:virtual int power()//2 要有虚函数重写{return 20;}private:};
//多态威力
//1 PlayObj给对象搭建舞台  看成一个框架
void PlayObj(HeroFighter *hf, EnemyFighter *ef)
{//不写virtual关键字 是静态联编 C++编译器根据HeroFighter类型,去执行 这个类型的power函数 在编译器编译阶段就已经决定了函数的调用//动态联编: 迟绑定:  //在运行的时候,根据具体对象(具体的类型),执行不同对象的函数 ,表现成多态.if (hf->power() > ef->attack())//hf->power()函数调用会有多态发生{printf("主角win\n");}else{printf("主角挂掉\n");}
}
//未来在增加 框架依然适用
class AdvAdvHeroFighter : public HeroFighter
{
public:virtual int power(){return 30;}
};void main()
{HeroFighter		hf;AdvHeroFighter	Advhf;EnemyFighter	ef;//3 用父类指针(父类引用)指向子类对象....PlayObj(&hf, &ef);	//主角挂掉PlayObj(&Advhf, &ef);//主角winAdvAdvHeroFighter advadvhf;PlayObj(&advadvhf, &ef);	//主角挂掉cout << "hello..." << endl;system("pause");return;
}

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、静态联编（static binding），是程序的匹配、连接在编译阶段实现，也称为早期匹配。

    重载函数使用静态联编。

3、动态联编是指程序联编推迟到运行时进行，所以又称为晚期联编（迟绑定）。

switch 语句和 if 语句是动态联编的例子。

4、理论联系实际

虚析构函数 若不加virtual关键字 析构时候只会析构父类，这样就会造成内存泄漏

//dm15_虚析构函数#define _CRT_SECURE_NO_WARNINGS
#include 
using namespace std;//虚析构函数
class A
{
public:A(){p = new char[20];strcpy(p, "obja");printf("A()\n");}virtual ~A(){delete[] p;printf("~A()\n");}
protected:
private:char *p;
};class B : public A
{
public:B(){p = new char[20];strcpy(p, "objb");printf("B()\n");}virtual ~B(){delete[] p;printf("~B()\n");}
protected:
private:char *p;
};class C : public B
{
public:C(){p = new char[20];strcpy(p, "objc");printf("C()\n");}virtual ~C(){delete[] p;printf("~C()\n");}
protected:
private:char *p;
};//只执行了 父类的析构函数
//向通过父类指针  把 所有的子类对象的析构函数 都执行一遍
//向通过父类指针 释放所有的子类资源 
void howtodelete(A *base)
{delete base;  //这句话不会表现成多态 这种属性
}/*
void howtodelete(B *base)
{
delete base;  //这句话不会表现成多态 这种属性
}
*/
void main()
{C *myC = new C; //new delete匹配//delete myC; //直接通过子类对象释放资源 不需要写virtual howtodelete(myC);//加virtual后,析构掉所有的cout << "hello..." << endl;system("pause");return;
}

//dm16_重载重写重定义#include using namespace std;//重写 重载 重定义
//重写发生在2个类之间
//重载必须在一个类之间//重写分为2类
//1 虚函数重写  将发生多态
//2 非虚函数重写 （重定义）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;}virtual void func(int i, int j, int m, int n){cout << "func() do..." << i << " " << j << endl;}
protected:
private:
};class Child : public Parent
{public:void abc(){printf("child abc");}/*void abc(int a){printf("child abc");}*/virtual void func(int i, int j){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.." << endl;}
protected:
private:
};//重载重写和重定义
void main()
{//: error C2661: “Child::func”: 没有重载函数接受 0 个参数Child c1;//c1.func();//子类无法重载父类的函数，父类同名函数将被名称覆盖c1.Parent::func();//1 C++编译器 看到func名字 ,因子类中func名字已经存在了(名称覆盖).所以c++编译器不会去找父类的4个参数的func函数//2 c++编译器只会在子类中,查找func函数,找到了两个func,一个是2个参数的,一个是3个参数的.//3 C++编译器开始报错.....  error C2661: “Child::func”: 没有重载函数接受 4 个参数//4 若想调用父类的func,只能加上父类的域名..这样去调用..//c1.func(1, 3, 4, 5);c1.Parent::func(1, 3, 4, 5);//c1.func();//func函数的名字，在子类中发生了名称覆盖；子类的函数的名字，占用了父类的函数的名字的位置//因为子类中已经有了func名字的重载形式。。。。//编译器开始在子类中找func函数。。。。但是没有0个参数的func函数 cout << "hello..." << endl;system("pause");return;
}

面试题1：请谈谈你对多态的理解

面试题2：谈谈C++编译器是如何实现多态                         

c++编译器多态实现原理

面试题3：谈谈你对重写，重载理解

函数重载

必须在同一个类中进行

子类无法重载父类的函数，父类同名函数将被名称覆盖

重载是在编译期间根据参数类型和个数决定函数调用

函数重写

必须发生于父类与子类之间

并且父类与子类中的函数必须有完全相同的原型

使用virtual声明之后能够产生多态(如果不使用virtual，那叫重定义)

多态是在运行期间根据具体对象的类型决定函数调用

4.3多态原理探究

理论知识：

Ø  当类中声明虚函数时，编译器会在类中生成一个虚函数表

Ø  虚函数表是一个存储类成员函数指针的数据结构

Ø  虚函数表是由编译器自动生成与维护的

Ø  virtual成员函数会被编译器放入虚函数表中

Ø  当存在虚函数时，每个对象中都有一个指向虚函数表的指针（C++编译器给父类对象、子类对象提前布局vptr指针；当进行howToPrint(Parent *base)函数是，C++编译器不需要区分子类对象或者父类对象，只需要再base指针中，找vptr指针即可。）

Ø  VPTR一般作为类对象的第一个成员

4.3.1 多态的实现原理

说明1：

通过虚函数表指针VPTR调用重写函数是在程序运行时进行的，因此需要通过寻址操作才能确定真正应该调用的函数。而普通成员函数是在编译时就确定了调用的函数。在效率上，虚函数的效率要低很多。

说明2：

所以编译器不需要知道是子类对象还是父类对象 给我们程序员造成的假象 c++编译器能识别子类对象或者父类对象

//dm01_多态原理探究#include 
using namespace std;//多态成立的三个条件//1.要有继承
//2.要有方法的重写 -虚函数重写
//3.父类指针(引用)指向子类对象class Parent
{
public:Parent(int a = 0){this->a = a;}virtual void print() //1 动手脚  写virtal关键字 会特殊处理 //虚函数表{cout << "我是爹" << endl;}virtual void print2()  //1 动手脚  写virtal关键字 会特殊处理 //虚函数表{cout << "我是爹" << endl;}private:int a;
};class Child:public Parent
{
public://启动初始化列表Child(int a = 0, int b = 0) :Parent(a){this->b = b;}virtual void print(){cout << "我是儿子" << endl;}
private:int b;
};void HowToPlay(Parent *base)
{base->print();//有多态发生  //2 动手脚  //效果:传来子类对象 指向子类的打印函数 传来父类的对象 执行父类的打印函数//存在虚函数时，每个对象中都有一个指向虚函数表的指针(vptr指针)  父类对象和子类对象 都会有各自的vptr指针//当类中声明虚函数时，编译器会在类中生成一个虚函数表//虚函数表是一个存储类成员函数指针的数据结构//虚函数表是由编译器自动生成与维护的//virtual成员函数会被编译器放入虚函数表中//当编译器调用相应对象的虚函数 编译器就会根据对象的vptr指针 在所指的虚函数表中查找打印函数 并调用执行}void main()
{Parent	p1; //3 动手脚 提前布局  //用类定义对象的时候 C++编译器会在对象中添加一个vptr指针 Child	c1; //子类里面也有一个vptr指针HowToPlay(&p1);HowToPlay(&c1);cout << "hello..." << endl;system("pause");return;
}

4.3.2如何证明vptr指针的存在

//dm02_证明vptr指针的存在
#include using namespace std;class Parent1//4
{
public:Parent1(int a = 0){this->a = a;}void print(){cout << "我是爹" << endl;}
private:int a;
};class Parent2//4 ==》实际上却是8 说明存在一个指针大小 （32位下指针都是4个字节长度）
{
public:Parent2(int a = 0){this->a = a;}virtual void print(){cout << "我是爹" << endl;}
private:int a;
};void main()
{//加上virtual关键字 c++编译器会增加一个指向虚函数表的指针 。printf("sizeof(Parent):%d sizeof(Parent2):%d \n", sizeof(Parent1), sizeof(Parent2));cout << "hello..." << endl;system("pause");return;
}

4.3.3构造函数中能调用虚函数，实现多态吗

//dm03_vptr指针的分步初始化#include 
using namespace std;//构造函数中调用虚函数能发生多态吗?class Parent
{
public:Parent(int a = 0){this->a = a;print();//构造函数中调用虚函数  //这里调用父类的虚函数}virtual void print(){cout << "我是爹" << endl;}private:int a;
};class Child : public Parent
{
public:Child(int a = 0, int b = 0) :Parent(a){this->b = b;print();}virtual void print(){cout << "我是儿子" << endl;}
private:int b;
};void HowToPlay(Parent *base)
{base->print(); //有多态发生  //2 动手脚  }void main()
{Child  c1; //定义一个子类对象 ,在这个过程中,在父类构造函数中调用虚函数print 能发生多态吗?//c1.print();//1.要初始化 c1.vptr指针 初始化过程是分步的//2 当执行父类的构造函数的时候 c1的vptr指向父类的虚函数表 当父类的构造函数运行完毕后 会把c1的vptr指针指向子类的虚函数表//3 子类对象vptr指针分步完成的//==》 子类对象构造的时候 在父类的构造函数中调用虚函数 产生不了多态现象 原因就是子类对象vptr指针初始化时分步的cout << "hello..." << endl;system("pause");return;
}

面试题4：是否可类的每个成员函数都声明为虚函数，为什么。                   c++编译器多态实现原理

面试题5：构造函数中调用虚函数能实现多态吗？为什么？                            c++编译器多态实现原理      

面试题6：虚函数表指针（VPTR）被编译器初始化的过程，你是如何理解的？

                   c++编译器多态实现原理

面试题7：父类的构造函数中调用虚函数，能发生多态吗？                         c++编译器多态实现原理

面试题8：为什么要定义虚析构函数？

在什么情况下应当声明虚函数

Ø  构造函数不能是虚函数。建立一个派生类对象时，必须从类层次的根开始，沿着继承路径逐个调用基类的构造函数

Ø   析构函数可以是虚的。虚析构函数用于指引 delete 运算符正确析构动态对象

铁律1：指针是一种数据类型     

1）指针也是一种变量，占有内存空间，用来保存内存地址

测试指针变量占有内存空间大小

2）*p操作内存

在指针声明时，*号表示所声明的变量为指针

在指针使用时，*号表示操作指针所指向的内存空间中的值

         *p相当于通过地址(p变量的值)找到一块内存；然后操作内存

         *p放在等号的左边赋值（给内存赋值）

         *p放在等号的右边取值（从内存获取值）

3）指针变量和它指向的内存块是两个不同的概念

//含义1 给p赋值p=0x1111; 只会改变指针变量值，不会改变所指的内容；p = p +1; //p++

//含义2 给*p赋值*p='a'; 不会改变指针变量的值，只会改变所指的内存块的值

//含义3 =左边*p 表示给内存赋值， =右边*p 表示取值含义不同切结！

//含义4 =左边char *p

//含义5 保证所指的内存块能修改

4）指针是一种数据类型，是指它指向的内存空间的数据类型

含义1：指针步长（p++），根据所致内存空间的数据类型来确定

p++=è(unsigned char )p+sizeof(a);

结论：指针的步长，根据所指内存空间类型来定。

注意：     建立指针指向谁，就把把谁的地址赋值给指针。图和代码和二为一。        

                   不断的给指针变量赋值，就是不断的改变指针变量（和所指向内存空间没有任何关系）。

什么时候子类的步长与父类步长一样： 当子类继承父类后 不添加任何属性和方法 那么就不会出错

//dm04_父类指针和子类指针的步长#include using namespace std;//结论:
//多态是用父类指针指向子类对象 和 父类步长++,是两个不同的概念class Parent
{
public:Parent(int a = 0){this->a = a;}virtual void print(){cout << "我是爹" << endl;}private:int a;
};//成功 ,一次偶然的成功 ,必然的失败更可怕
class Child : public Parent
{
public:Child(int b = 0) :Parent(0){this->b = b;}virtual void print(){cout << "我是儿子" << endl;}
private:int b; //开始父类与子类 内存大小一样 但是当子类添加一个int b 这两个类的内存大小就不一样
};void HowToPlay(Parent *base)
{base->print(); //有多态发生  //2 动手脚  }void main()
{Child  c1; //定义一个子类对象 ,在这个过程中,在父类构造函数中调用虚函数print 能发生多态吗?//c1.print();Parent *pP = NULL;Child  *pC = NULL;Child  array[] = { Child(1), Child(2), Child(3) };pP = array;//让父类的指针指向子类的对象pC = array;pP->print();pC->print(); //多态发生//多态时候 用父类指针指向子类对象 和 父类步长++ 是两个不同的概念//当添加一个int b 后 两个指针的步长不一样pP++;pC++;pC->print(); //多态发生pP->print();//父类的步长不对劲  pP++ 后的位置不是下一个数组的入口地址位置  编译器就无法根据对象去用vptr指针去寻址要执行的虚函数//但是子类步长ok pC++后的位置是下一个数组的入口地址位置pP++;pC++;pP->print();pC->print(); //多态发生cout << "hello..." << endl;system("pause");return;
}

5、纯虚函数和抽象类

5.1基本概念

5.2抽象类案例

//dm05_纯虚函数抽象类语法基础#include using namespace std;//面向抽象类编程(面向一套预先定义好的接口编程)//一个具有纯虚函数的基类称为抽象类
//1.有继承
class Figure//抽象类
{
public://阅读一个统一的界面(接口),让子类使用,让子类必须去实现virtual void getArea() = 0; //纯虚函数  2.多态条件 有虚函数重写private:};class Circle:public Figure
{
public:Circle(int a){this->a = a;}virtual void getArea(){cout << "圆形的面积：" << 3.14*a*a << endl;}
private:int a;
};class Tri : public Figure
{
public:Tri(int a, int b){this->a = a;this->b = b;}virtual void getArea(){cout << "三角形的面积: " << a*b / 2 << endl;;}private:int a;int b;
};class Square : public Figure
{
public:Square(int a, int b){this->a = a;this->b = b;}virtual void getArea(){cout << "四边形的面积: " << a*b << endl;;}private:int a;int b;
};
//搭建一个舞台 看对象完整的生命周期
void objplay(Figure *base)
{base->getArea();//发生多态  3 父类指针(引用)指向子类对象
}
void main()
{//Figure f;//抽象类不能被实例化Figure *base = NULL;//抽象类不能被实例化Circle c1(10);Tri tr1(10,10);Square s1(10,10);//面向抽象类编程(面向一套预先定义好的接口编程)objplay(&c1);objplay(&tr1);objplay(&s1);cout << "hello..." << endl;system("pause");return;
}

5.3抽象类在多继承中的应用

C++中没有Java中的接口概念，抽象类可以模拟Java中的接口类。（接口和协议）

5.3.1有关多继承的说明 

工程上的多继承

被实际开发经验抛弃的多继承

工程开发中真正意义上的多继承是几乎不被使用的

多重继承带来的代码复杂性远多于其带来的便利

多重继承对代码维护性上的影响是灾难性的

在设计方法上，任何多继承都可以用单继承代替

多继承中的二义性和多继承不能解决的问题

//dm06_多继承的二义性#include 
using namespace std;class  B
{
public:int b;
protected:
private:
};class  B1 : virtual public B
{
public:int b1;
protected:
private:
};class  B2 : virtual public B
{
public:int b2;
protected:
private:
};class  C : public B1, public B2
{
public:int c;
protected:
private:
};//多继承暂时解决不了的
class D
{
public:int b;private:};class E :virtual public B, virtual public D
{
public:int e;private:};void main()
{C myc;myc.c = 10;//多继承的二义性  error C2385: 对“b”的访问不明确 通过添加virtual能够解决myc.b = 100;E e1;e1.e = 20;//多继承的二义性 解决不了的问题e1.b = 10;cout << "hello..." << endl;system("pause");return;
}

5.3.2多继承的应用场景

//dm07_抽象类在多继承中的应用#include using namespace std;class Interface1
{
public:virtual int add(int a,int b) = 0;virtual void print() = 0;
private:};class Interface2
{
public:virtual int mult(int a, int b) = 0;virtual void print() = 0;
};class Parent
{
public:int getA(){a = 0;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 mult(int a, int b){cout << "Child:mult" << endl;return a * b;}private:};void main()
{Child c1;c1.print();Interface1 *it1 = &c1;it1->add(1, 2);Interface2 *it2 = &c1;it2->mult(3, 6);cout << "hello..." << endl;system("pause");return;
}

5.4抽象类知识点强化

/*

编写一个C++程序, 计算程序员( programmer )工资

         1要求能计算出初级程序员( junior_programmer ) 中级程序员 ( mid_programmer )高级程序员( adv_programmer)的工资

         2要求利用抽象类统一界面,方便程序的扩展, 比如:新增, 计算架构师 (architect ) 的工资

*/

//dm08_面向抽象类编程计算程序员工资#include 
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;
};//1多态的条件 要有继承
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()//2多态的条件 要有虚函数重写{cout << name << " " << job << " : " << sal << endl;}
private:char *name;char *job;int sal;
};
//3.父类指针(引用)指向子类对象 多态的条件
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()//2多态的条件 要有虚函数重写{cout << name << " " << job << " : " << sal << endl;}
private:char *name;char *job;int sal;
};
void main()
{junior_programmer jp("小王", "初级", 4000);mid_programmer mp("小张", "中级", 8600);adv_programmer ap("小李", "高级", 15000);CalProSal(&jp);CalProSal(&mp);CalProSal(&ap);//系统扩展architect ar("传智高水平学员", "架构师", 24000);CalProSal(&ar);cout << "hello..." << endl;system("pause");return;
}

本文来自互联网用户投稿，文章观点仅代表作者本人，不代表本站立场，不承担相关法律责任。如若转载，请注明出处。 如若内容造成侵权/违法违规/事实不符，请点击【内容举报】进行投诉反馈！