继承

继承：在已有类的基础上创建新类的过程。
一个 B 类继承A类，或称从类 A 派生类 B。
类 A 称为基类（父类），类 B 称为派生类（子类）。

类继承的语法形式：

class 派生类名 : 基类名表
{数据成员和成员函数声明
};

基类名表构成：
访问控制 基类名1， 访问控制 基类名2 ，… ， 访问控制 基类名n

访问控制 表示派生类对基类的继承方式，使用关键字：public 公有继承
private 私有继承
protected 保护继承

*不论种方式继承基类，派生类都不能直接使用基类的私有成员

派生类生成过程：
1、吸收基类成员：在C++的继承机制中，派生类吸收基类中除构造函数和析构函数之外的全部成员。
2、改造基类成员：通过在派生类中定义同名成员（包括成员函数和数据成员）来屏蔽（隐藏）在派生类中不起作用的部分基类成员。
3、添加新成员：仅仅继承基类的成员是不够的，需要在派生类中添加新成员，以保证派生类自身特殊属性和行为的实现。

举例：

class Father
{int a,b;public:// 成员函数
};
class Son:public Father
{int c;public:// 成员函数
};

公有继承：
基类的protected成员和public成员能被继承，private成员不能被派生类继承。

重名成员：
派生类定义了与基类同名的成员，在派生类中访问同名成员时屏蔽（hide）了基类的同名成员。在派生类中使用基类的同名成员，显式地使用类名限定符：类名 :: 成员。

重名数据成员例：

class  base
{ public :int  a ,  b ;  
} ;
class  derived : public  base
{ public :  int  b ,  c ; 
} ;
void  f ()
{ derived  d ;d . a = 1 ;d . base :: b = 2 ;d . b = 3 ;d . c = 4 ;
};

派生类访问静态成员：
基类定义的静态成员，将被所有派生类共享（基类和派生类共享基类中的静态成员）。派生类中访问静态成员，用以下形式显式说明：类名 :: 成员。或通过对象访问：对象名 . 成员。

基类初始化：派生类构造函数和析构函数的定义规则：
1、基类的构造函数和析构函数不能被继承；
2、如果基类没有定义构造函数或有无参的构造函数， 派3、生类也可以不用定义构造函数；
4、如果基类无无参的构造函数，派生类必须定义构造函数；
5、如果派生类的基类也是派生类，则每个派生类只负责直接基类的构造；
6、派生类是否定义析构函数与所属的基类无关。

*派生类的数据成员既包括基类的数据成员，也包括派生类新增数据成员。

问题：如何对基类中的成员进行初始化？
回答：调用基类构造函数对基类成员进行初始化。

派生类构造函数一般格式：
派生类::派生类名(参数总表):基类名(参数表)
{
// 派生类新增成员的初始化语句
}
注意：这是基类有构造函数且含有参数时使用

派生类析构函数：

举例：

class B
{
public:B() { cout<<"B()"<<endl; }~B() { cout<<"~B()"<<endl; }
};
class D : public B
{
public:D(){ cout<<"D()"<<endl; }~D() { cout<<"~D()"<<endl; }
};
int main()
{D d;return 0;
}

多继承

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

多继承声明语法：

class  派生类名 : 访问控制  基类名1 ,  访问控制  基类名2 ,  … , 访问控制  基类名n
{数据成员和成员函数声明
}；

多继承举例：

class Base1
{ 
public:Base1(int x) { value = x ; }int getData() const { return value ; }
protected:int value;
};class Base2
{ 
public:Base2(char c) { letter=c; }char getData() const { return letter;}
protected:char letter;
};class Derived : public Base1, public Base2
{   
friend ostream &operator<< ( ostream &, const Derived & ) ;
public :Derived ( int, char, double ) ;double getReal() const ;
private :double real ;
};int main()
{ Base1 b1 ( 10 ) ;Base2 b2 ( 'k' ) ;Derived d ( 5, 'A', 2.5 ) ;:return ;
}

结果：

多继承构造函数：

派生类名(参数总表):基类名1(参数表1),基类名2(参数表2),…,基类名n(参数表n)
{// 派生类新增成员的初始化语句
} 

构造函数执行顺序：先执行所有基类的构造函数，再执行对象成员的构造函数，最后执行派生类的构造函数。

多继承析构函数：

虚基类：如果一个派生类从多个基类派生，而这些基类又有一个共同的基类，则在对该基类中声明的名字进行访问时，可能产生二义性。
如果在多条继承路径上有一个公共的基类，那么在继承路径的某处汇合点，这个公共基类就会在派生类的对象中产生多个基类子对象。要使这个公共基类在派生类中只产生一个子对象，必须对这个基类声明为虚继承，使这个基类成为虚基类。
虚继承声明使用关键字：virtual。

赋值兼容规则：赋值兼容规则指在程序中需要使用基类对象的任何地方，都可以用公有派生类的对象来替代。
替代包括一下情况：
1、派生类的对象可以赋给基类对象；
2、派生类的对象可以初始化基类的引用；
3、派生类的对象的地址可以赋给基类类型的指针。

例如,下面声明的两个类:

class Base{…
};
class Derived:public Base{
…
};

根据赋值兼容规则, 以下几种情况是合法的:
(1) 可以用派生类对象给基类对象赋值。例如:
Base b;
Derived d;
b=d;
这样赋值的效果是,对象b中所有数据成员都将具有对象d中对应数据成员的值。
(2) 可以用派生类对象来初始化基类的引用。例如:
Derived d;
Base &br=d;
(3) 可以把派生类对象的地址赋值给指向基类的指针。例如:
Derived d;
Base *bptr=&d;
这种形式的转换,是在实际应用程序中最常见到的。
(4) 可以把指向派生类对象的指针赋值给指向基类对象的指针。例如:
Derived *dptr,obj; dptr=&obj;
Base *bptr=dptr;

赋值兼容规则的特点：在替代之后，派生类对象就可以作为基类的对象使用，但只能使用从基类继承的成员。

赋值兼容应注意的问题：

多态

多态性：多态性（Polymorphism）是指一个名字，多种语义；或界面相同，多种实现。重载函数是多态性的一种简单形式。虚函数允许函数调用与函数体的联系在运行时才进行，称为动态联编。

多态的实现：
多态从实现的角度来讲可以划分为两类:编译时的多态和运行时的多态。
编译时的多态是通过静态联编来实现的。静态联编就是在编译阶段完成的联编。编译时多态性主要是通过函数重载和运算符重载实现的。
运行时的多态是用动态联编实现的。动态联编是运行阶段完成的联编。运行时多态性主要是通过虚函数来实现的。

静态联编：
普通成员函数重载可表达为两种形式：

1. 在一个类说明中重载
   例如：void Show ( int , char ) ;
   void Show ( char * , float ) ;
2. 基类的成员函数在派生类重载。有 3 种编译区分方法：
   （1）根据参数的特征加以区分
   例如：void Show ( int , char )； 与
   void Show ( char * , float )； 不是同一函数，编译能够区分
   （2）使用“ :: ”加以区分
   例如： A :: Show ( )；
   有别于 B :: Show ( )；
   （3）根据类对象加以区分
   例如： Aobj . Show ( ) 调用 A :: Show ( )
   Bobj . Show ( ) 调用 B :: Show ( )

基类指针和派生类指针与基类对象和派生类对象4种可能匹配：
1、直接用基类指针引用基类对象；
2、直接用派生类指针引用派生类对象；
3、用基类指针引用一个派生类对象；
4、用派生类指针引用一个基类对象。

例如：
A * p ; // 指向类型 A 的对象的指针
A A_obj ; // 类型 A 的对象
B B_obj ; // 类型 B 的对象
p = & A_obj ; // p 指向类型 A 的对象
p = & B_obj ; // p 指向类型 B 的对象，它是 A 的派生类
利用 p，可以通过 B_obj 访问所有从 A 类继承的元素 ，
但不能用 p访问 B 类自定义的元素 （除非用了显式类型转换）*

派生类指针引用基类对象：派生类指针只有经过强制类型转换之后，才能引用基类对象

虚函数

冠以关键字 virtual 的成员函数称为虚函数。

根据赋值兼容，用基类类型的指针指向派生类，就可以通过这个指针来使用类（基类或派生类）的成员函数。
如果这个函数是普通的成员函数，通过基类类型的指针访问到的只能是基类的同名成员。
而如果将它设置为虚函数，则可以使用基类类型的指针访问到指针正在指向的派生类的同名函数。从而实现运行过程的多态。

实现动态联编方式的前提：
1、先要声明虚函数
2、类之间满足赋值兼容规则
3、通过指针与引用来调用虚函数。

注意：
1、一个虚函数，在派生类层界面相同的重载函数都保持虚特性；
2、虚函数必须是类的成员函数；
3、不能将友元说明为虚函数，但虚函数可以是另一个类的友元；
4、析构函数可以是虚函数，但构造函数不能是虚函数。

虚函数的重载特性：在派生类中重载基类的虚函数要求函数名、返回类型、参数个数、参数类型和顺序完全相同。

例子：

class  base
{ 
public: virtual  void  vf1 ( ) ;virtual  void  vf2 ( ) ;virtual  void  vf3 ( ) ;void  f ( ) ;
};class  derived : public  base
{ 
public : void  vf1 ( ) ;		// 虚函数void  vf2 ( int ) ;	// 重载，参数不同，虚特性丢失char  vf3 ( ) ;		// error，仅返回类型不同void f ( ) ;		// 非虚函数重载
};void  g ( ) 
{ derived   d ;base  * bp = & d ; // 基类指针指向派生类对象bp -> vf1 ( ) ;	   // 调用 deriver :: vf1 ( )bp -> vf2 ( ) ;	   // 调用 base :: vf2 ( )bp -> f ( ) ;	   // 调用 base :: f ( )
};

虚析构函数：构造函数不能是虚函数。建立一个派生类对象时，必须从类层次的根开始，沿着继承路径逐个调用基类的构造函数。析构函数可以是虚的。虚析构函数用于指引 delete 运算符正确析构动态对象 。

例子：

#include<iostream>
using namespace std ;
class A
{ 
public:~A(){ cout << "A::~A() is called.\n" ; }
};class B : public A
{ 
public:~B(){ cout << "B::~B() is called.\n" ; }
};int main() 
{A *Ap = new B ;	B *Bp2 = new B ;cout << "delete first object:\n" ;delete Ap;cout << "delete second object:\n" ;delete Bp2 ;
} 

结果：


纯虚函数：纯虚函数是一个在基类中说明的虚函数，在基类中没有定义， 要求任何派生类都定义自己的版本。纯虚函数为各派生类提供一个公共界面。
纯虚函数说明形式：
virtual 类型 函数名（参数表）= 0 ;
一个具有纯虚函数的基类称为抽象类。

例子：

class figure
{ protected : double x,y;public:    void set_dim(double i, double j=0) { x = i ;  y = j ; }virtual void show_area() = 0 ;
};
class triangle : public figure
{ public :void show_area(){ cout<<"Triangle with high "<<x<<" and base "<<y <<" has an area of "<<x*0.5*y<<"\n"; }
};
class square : public figure
{ public:void show_area(){ cout<<"Square with dimension "<<x<<"*"<<y <<" has an area of "<<x*y<<"\n"; }
};
class circle : public figure
{ public:void show_area(){ cout<<"Circle with radius "<<x;cout<<" has an area of "<<3.14*x*x<<"\n";}
};

感想

经历了这12周的网课，”程序设计B“在疫情之中度过了。实话说，这个学期的网课我上得质量不高，远不比在教室里上来得认真细致，本以为自己能安静在家一个人好好上课，但是还是有很多其他因素影响，包括我自身也是松懈不少，少了一种学习的环境，老师上课依然和在教室里一样认真负责，甚至比线下上课付出更多，没把握好机会好好学习确实很可惜，随着课程逐渐结课，我只能通过回放和书本来复习，反而会花更多的时间，我希望能吸取这次疫情上网课的教训，在今后的人生道路上警示自己，提高自控力，优秀的人总是比你更努力。
感谢老师这12周来认真负责的态度和严谨的教学，在接下来的课程设计和实验中，我希望学到更多知识，巩固好学过的知识，打好基础才能走得更远，学得更多才能走向成功。