继承与派生笔记

第七章 继承与派生

类的继承与派生：
保持已有类的特性而构造新类的过程称为继承。
在已有类的基础上，新增自己的特性，产生新类的过程称为派生。
  继承与派生其实是同一过程从不同的角度看，我们将保持已有类的特性而构造新类的过程称为继承，说白了继承的目的就是实现原来设计与代码的重用，希望尽量利用原有的类。然而当新的问题出现，原有程序无法解决或不能完全解决时，需要对原有程序进行改造，在已有类的基础上新增自己的特性而产生新类的过程称为派生。相关重要概念整理如下：

基类（父类）：被继承的已有类
派生类：派生出的新类

继承的目的：实现代码的重用
派生的目的：当新的问题出现，原程序无法解决时，需要对原有程序进行改造；

派生类的声明：
class 派生类名：继承方式 基类名
{
	成员说明；
}

继承方式：
公有继承：public
私有继承：private
保护继承：protected
不同继承方式决定了：派生类成员和对象对基类成员的访问权限

public：公有继承
基类public和protected成员的访问在派生类保持不变，但基类的privated不可以直接访问。
派生类的成员函数可以以访问基类中的：public和protected
派生类对象只能访问public；

公有继承举例：

#include<iostream>
using namespace std;
class Point 
{
	public:
		Point(int xx=0,int yy=0){
			X=xx;
			Y=yy;
		}
		void add(int x,int y){
			x=x+x;
			y=y+y;
		}
		void A(int x,int y){
			cout<<"输出为"<<x<<" "<<y<<endl; 
		}
		
	private:
		int X;
		int Y;
 } ;
 class Other : public Point //other类中不能出现X，Y；
 {
 public:
 Other(int xx=0,int yy=0,int ww=0,int hh=0){
 	Point(xx,yy);  //使用基类的构造函数。
 	W=ww;
 	H=hh;
 }
 void B(int x,int y,int w,int h){
 	cout<<"输出为"<<x<<" "<<y<<" "<<w<<" "<<h<<endl;
 }
 
 
 private:
 int W;
 int H; 
 	
 };
 
		int main()
	{
	Other C(1,2,3,4);
	C.A(1,2);//可以调用基类的public成员函数；
	C.B(1,2,3,4);
	return 0;
 	}		 

输出：
输出为1 2
输出为1 2 3 4



private：私有继承：
基类中的public和protected在派生类中都以private的身份出现；
基类的private不可以直接被派生类访问；
派生类成员函数可以直接访问基类的public和protected
派生类对象不可以直接访问基类找那个的任何成员；

上个例子，将public改为private，A成员函数将不能直接被对象C使用；
 class Other : private Point 
 {
 public:
 Other(int xx=0,int yy=0,int ww=0,int hh=0){
 	Point(xx,yy);
 	W=ww;
 	H=hh;
 }
 void B(int x,int y,int w,int h){
 	Point::A(x,y); //只能在函数中引用函数，不能再对象中引用；
 	cout<<"输出为"<<x<<" "<<y<<" "<<w<<" "<<h<<endl;
 }
 
 
 private:
 int W;
 int H; 
 	
 };
 		int main()
	{
	Other C(1,2,3,4);

	C.B(1,2,3,4);
	return 0;
 	}


protected：保护继承
基类中的public和protected成员都以protected身份出现在派生类中，基类的private的成员不可以直接访问；
派生类的成员函数可以直接访问基类中的public和protected成员；
不能访问private成员；
派生类中的对象不能访问任何成员；

protected特点和作用：
对其建立的类对象的模块来说，与private性质相同；
对派生类来说，与public成员性质相同；
既实现了数据隐藏又方便继承，实现代码重用；

class A {
     protected:
                    int x;
}
int main()
{
      A a;
      a.x=5;    //错误 ，对象不能访问基类的任何成员；
}

类型兼容规则：
一个公有派生类的对象在使用上可以当做基类的对象；
具体表现在：
派生类的对象可以被赋值给基类对象；
派生类对象可以初始化基类的引用；
指向基类的指针可以指向派生类；

通过基类对象名，指针只能使用从基类继承的成员；
举例：
#include<iostream>
using namespace std;
class P0
{
	public:
	void display(){
		cout<<"P0"<<endl;
	}
	 
 } ;
 class P1 : public P0
 {
 public:
  void display(){
  	cout<<"P1"<<endl;
  }
 };


 
 class P2: public P1
 {
 	
 	public:
 		void display(){
 			cout<<"P2"<<endl;
 			
		 }
 		
  }; 
  
  void fun(P0 *p)
  {
  	p->display();
  }
	int main()
	{
		P0 p0;
		P1 p1;
		P2 p2;
		P0 *p;
		p0.display();
		p=&p0;
		fun(p);
		p=&p1;
		p1.display();
		fun(p);
		p=&p2;
		p2.display();
		fun(p);
		return 0;
			 }		 

输出：
P0
P0
P1
P0
P2
P0
此结果说明了
通过基类对象名，指针只能使用从基类继承的成员；

将指针换成P1型，那么指针只能指向p1和p2不能指向p0；
只能指向自己和派生的类；

基类和派生类的对应关系：
单继承：
派生类只能从一个基类中派生；
多继承：
派生类从多个基类中派生；
多重派生：
有一个基类派生出多个不同的派生类；
多层派生：
派生类作为基类，继续派生新的基类；

多继承时派生类的声明：
class 派生类名：继承方式1 基类名1，继承方式2 基类名2，.....
{
	成员声明；
}
class C : public A, private B
{

}


继承时的构造函数：
基类的构造函数不会被继承，派生类中需要声明自己的构造函数；
声明构造函数时，只需要对新增成员的初始化，对继承来的基类成员的初始化，自动调用基类的构造函数；
派生类的构造函数需要给积累的构造函数传递参数；

单一继承时的构造函数：
派生类名：：派生类名（基类所需的形参，本类所需的形参）：基类名（参数表）
{
	本类成员初始化赋值语句；
}
举例：
#include<iostream>
using namespace std;
class B{
     public:
	       B();
	       B(int i);
	       ~B();
	       void Print() const;
     private:
	       int b;
};
B::B()
{	b=0;
	cout<<"B's default constructor called."<<endl;
}
B::B(int i)
{	b=i;
    cout<<"B's constructor called." <<endl;
}
B::~B()
{	cout<<"B's destructor called."<<endl;  }
void B::Print() const
{	cout<<b<<endl;  }
class C:public B
{
    public:
      C();
	  C(int i,int j);
	  ~C();
	  void Print() const;
	private:
	  int c;
};
C::C()
{	c=0;
	cout<<"C's default constructor called."<<endl;
}
C::C(int i,int j):B(i), c(j) //这条才是此程序重点；
{
	cout<<"C's constructor called."<<endl;
}
C::~C()
{	cout<<"C's destructor called."<<endl; }
void C::Print() const
{	B::Print();
	cout<<c<<endl;  }
int  main()
{	C obj(5,6);	
	obj.Print();  }

输出：
B's constructor called.
C's constructor called.
5
6
C's destructor called.  //析构函数最后被运行，而且和构造函数调用相反；
B's destructor called.
说明：C::C(int i,int j):B(i), c(j) //这条才是此程序重点；
单一继承时的构造函数使用方法；


多继承时的构造函数：
派生类名：：派生类名（基类1形参，基类2形参....基类3形参）：基类名1（参数，基类名2（参数）....，基类名n（参数））
{
本类成员初始化赋值语句；
}


派生类和基类的构造函数：
当基类中声明默认形式的构造函数或者未声明构造函数时，派生类构造函数可以不向基类构造函数传递参数；
当基类中未声明构造函数时，派生类中页可以不声明，全部采用缺省形式构造函数；
当基类声明带形参的构造函数时，派生类也应声明带形参的构造函数，并将参数传递给基类构造函数；


多继承且具有内嵌对象时的构造函数：
派生类名：：派生类名（基类1形参，基类2形参，...基类n形参，本类形参）：
基类名1（参数），基类名2（参数）....基类名n（参数），对象数据成员的初始化
{
本类成员初始化赋值语句；
}；


构造函数的调用次序：
1.调用基类构造函数，顺序按照被继承时的顺序；
2.调用成员对象的构造函数。按照他们在类中的声明顺序；
3.派生类的构造函数体中的内容；

拷贝构造函数：
建立派生类对象时，调用缺省拷贝构造函数，则编译器自动调用基类的缺省考本构造函数；
若编写派生类的拷贝构造函数，则需要为基类的拷贝构造函数传递参数；
例如：
C：：C（C&c1）：B（c1）
{
	......
}

派生类构造函数举例：

#include <iostream>
using namecpace std;
class B1	//基类B1，构造函数有参数
{public:
	B1(int i) {cout<<"constructing B1 "<<i<<endl;}
};
class B2	//基类B2，构造函数有参数
{public:
	B2(int j) {cout<<"constructing B2 "<<j<<endl;}
};
class B3	//基类B3，构造函数无参数
{public:
	B3(){cout<<"constructing B3 *"<<endl;}
};
class C: public B2, public B1, public B3 
{
public:	//派生类的公有成员
	C(int a, int b, int c, int d): 
       B1(a),memberB2(d),memberB1(c),B2(b)  {}
private:	//派生类的私有对象成员
	B1 memberB1;
	B2 memberB2;
	B3 memberB3;
};
void main()
{	C obj(1,2,3,4);  }

运行结果：
constructing B2 2
constructing B1 1
constructing B3 *
constructing B1 3
constructing B2 4
constructing B3 *

结果分析：

构造函数的调用次序：
1.调用基类构造函数，顺序按照被继承时的顺序；
2.调用成员对象的构造函数。按照他们在类中的声明顺序；
3.派生类的构造函数体中的内容；

继承顺序：
调用基类构造函数：
class C: public B2, public B1, public B3 ；所以前三行确定；
调用成员对象构造函数：
	B1 memberB1;
	B2 memberB2;
	B3 memberB3;
	所以，MB1，MB2，MB3；


继承时的析构函数：
析构函数不会被继承，派生类自行声明；
声明方法与一般类相同；
不需要显示调用，系统会自动隐式调用；
析构函数调用次序与构造函数相反；


同名隐藏规则：
当派生类与基类有相同成员时：
若未强行指名，则通过派生类对象访问的是派生类的同名成员；
如果通过派生类对象访问基类被覆盖的同名成员，应该使用基类名限定；
多继承同名隐藏举例：
#include <iostream>
using namecpace std;
class B1	//声明基类B1
{ public:	//外部接口
	int nV;
	void fun()  {cout<<"Member of B1"<<endl;}
};
class B2	//声明基类B2
{ public:	//外部接口
	int nV;
	void fun(){cout<<"Member of B2"<<endl;}
};
class D1: public B1, public B2	 
{ public:
	int nV;	//同名数据成员
	void fun(){cout<<"Member of D1"<<endl;}	//同名函数成员
};
void main()
{	D1 d1;
	d1.nV=1;  //对象名.成员名标识, 访问D1类成员
	d1.fun();	         
	
	d1.B1::nV=2;	//作用域分辨符标识, 访问基类B1成员
	d1.B1::fun();	
	
	d1.B2::nV=3;	//作用域分辨符标识, 访问基类B2成员
	d1.B2::fun();	
}
说明：
d1.nV=1;  //对象名.成员名标识, 访问D1类成员
d1.B1::nV=2;	//作用域分辨符标识, 访问基类B1成员
d1.B2::nV=3;	//作用域分辨符标识, 访问基类B2成员

二义性问题：
在多继承时，基类与派生类之间，或基类之间出现同名成员时，将出现访问时的二义性，采用虚函数或者同名隐藏规则来解决；
当派生类从多个基类派生，而这些基类又从同一个基类派生，则在访问此共同基类中的成员时，将产生二义性，采用虚基类解决；
二义性问题举例1：
class A
{
    public:
        void  f();
};
class B
{
    public:
        void f();
        void g()
};

class C: public A, piblic B
{         public:
           void g();
           void h();
};
如果声明：C  c1;
则  c1.f();  具有二义性
而  c1.g();  无二义性（同名隐藏）

解决方法：
解决方法一：用类名来限定c1.A::f()    或    c1.B::f()
解决方法二：同名隐藏在C 中声明一个同名成员函数f()，f()再根据需要调用  A::f()    或    B::f()

二义性问题举例2：
class B
{         public:
            int b;
}
class B1 : public B
{
       private:
            int b1;
}
class B2 : public B
{
       private:
            int b2;
};
class C : public B1,public B2
{
       public:
           int f();
       private:
           int d;
}
有二义性：    
C  c;				B类成员：b
c.b                 B1类成员：b，b1
c.B::b              B2类成员：b，b2
无二义性：           C类对象：B1：b，b1，B2：b，b2，d；
c.B1::b
c.B2::b


虚基类：
虚基类的引入：用于有共同基类的场合；
声明:
以virtual修饰说明基类；
例子：class B1：virtual public B;
作用：
主要解决多继承时可能发生的对同一基类继承多次而产生的二义性问题；
为最远的派生类提供唯一的基类成员，而不重复产生多次拷贝；
注意：在第一级继承时就要将共同基类设计为虚基类。

class B{ public: int b;};
class B1 : virtual public B {public : int b1;};
class B2 : virtual public B {public : int b2;};
class C : public B1, public B2{public : float d;}

下面的访问是正确的：
C  cobj;
cobj.b; 访问的就是B中的b；
B1.b和B2.b都指向了B.b；
不存在二义性；

举例：
#include <iostream>
using namecpace std;
class B0	//声明基类B0
{ public:	//外部接口
	int nV;
	void fun(){cout<<"Member of B0"<<endl;}
};
class B1: virtual public B0  //B0为虚基类，派生B1类
{ public:	//新增外部接口
	int nV1;
};
class B2: virtual public B0  //B0为虚基类，派生B2类
{  public:	//新增外部接口
	int nV2;
};

class D1: public B1, public B2	//派生类D1声明
{  public:	//新增外部接口
	int nVd;
	void fund(){cout<<"Member of D1"<<endl;}
};
void main()	//程序主函数
{   D1 d1;	//声明D1类对象d1
	d1.nV=2;	//使用最远基类成员
	d1.fun();
}
输出结果：Member of B0


虚基类及其派生类构造函数
建立对象时，所指定的类称为最（远）派生类
虚基类的成员是通过最派生类的构造函数通过调用虚基类的构造函数初始化；
即：B0的成员是通过B1的构造函数调用B0的构造函数初始化的；
太绕了：
在整个继承结构中，直接或间接继承虚基类的所有派生类，都必须在构造函数的成员初始化表中给出对虚基类的构造函数的调用。如果未列出，则表示调用该虚基类的缺省构造函数。
在建立对象时，只有最派生类的构造函数调用虚基类的构造函数，该派生类的其它基类对虚基类构造函数的调用被忽略。


有虚基类时的构造函数举例：
class B0	//声明基类B0
{ public:	//外部接口
	B0(int a) : nV(a) { }
	int nV;
	void fun(){cout<<"Member of B0"<<endl;}
};
class B1: virtual public B0	 
{  public:	
	B1(int a, int b) : B0(a), nV1(b) { }
	int nV1;
};
class B2: virtual public B0	 
{  public:	
	B2(int a, int c) : B0(a), nV2(c) { }
	int nV2;
};
class D1: public B1, public B2
{
public:	
	D1(int a, int b, int c, int d) : B0(a), B1(a, b), B2(a, c), nVd(d) { }
	int nVd;
	void fund(){cout<<"Member of D1"<<endl;}
};
void main()	
{
	D1 d1(1, 2, 3, 4);
	d1.nV=5;
	d1.fun();
}
输出：Member of B0