C++面向对象之继承

一、继承概念

继承(inheritance)机制是面向对象程序设计使代码可以复用的最重要的手段，它允许程序在保持原有类特性的基础上

进行扩展，增加功能。这样产生新的类，称派生类。继承呈现了面向对象程序设计的层次结构，体现了由简单到复杂的认知过程。

1.继承定义格式

2.继承关系

总结：

（1）基类的private成员在派生类中是不能被访问的，如果基类成员不想在类外直接被访问但需要在派生类中能访问，就定义为protected。可以看出保护成员限定符是因继承才出现的。

（2） public继承是一个接口继承，保持is-a原则，每个父类可用的成员对子类也可用，因为内个子类对象也都是一个父类对象（子类继承父类的成员）

（3）protected/private继承是一个实现继承，基类的部分成员并非完全成为子类接口的一部分，是 has-a 的关系原则，所以非特殊情况下不会使用这两种继承关系，在绝大多数的场景下使用的都是公有继承。私有继承以为这is-implemented-in-terms-of(是根据……实现的)。通常比组合(composition)更低级，但当一个派生类需要访问基类保护成员或需要重定义基类的虚函数时它就是合理的。

（4）不管是哪种继承方式，在派生类内部都可以访问基类的公有成员和保护成员，基类的私有成员存在但是在子类中不可见（不能访问）。

（5）使用关键字class时默认的继承方式是private，使用struct时默认的继承方式是public，不过最好显式的给出继承方式。

（6）在实际运用中一般使用都是public继承，极少场景下才会使用protected/private继承.派生类的默认成员函数在继承关系里面，在派生类中如果没有显示定义这六个成员函数，编译系统则会默认合成六个默认的成员函数。

3.继承关系中构造函数调用顺序

class Base  //基类
{
public:
	Base()
	{
		cout<<"Base()"<<endl;
	}

	~Base()
	{
		cout<<"~Base()"<<endl;
	}

public:
	int _pub;
protected:
	int _pro;
private:
	int _pri;
};

class Derived:public Base   //派生类
{
public:
	Derived()
	{
		cout<<"Derived()"<<endl;
	}
	
	~Derived()
	{
		cout<<"~Derived()"<<endl;
	}

private:
	int _pubD;
	int _proD;
	int _priD;
};

void FunTest1()
{
	//Base b;
	Derived d;
}

int main()
{
	FunTest1();

	system("pause");
	return 0;
}

则可以看出，创建对象时，先调用基类的构造函数，在调用派生类的构造函数（实际上是先调用派生类的构造函数，在派生类构造函数的初始化列表中调用基类构造函数，则会先执行基类的构造函数函数体），在清理对象时，则会先调用派生类的析构函数，再调用基类的析构函数。

【说明】

基类没有缺省构造函数，派生类必须要在初始化列表中显式给出基类名和参数列表。

基类没有定义构造函数，派生类也可以不用定义，全部使用缺省构造函数。

基类定义了带有形参表构造函数，派生类就一定定义构造函数。

4.继承体系中的作用域

（1）在继承体系中基类和派生类是两个不同作用域

（2）子类和父类中有同名成员，子类成员将屏蔽父类对成员的直接访问（可以采用基类::基类成员来访问）

#include <iostream>
using namespace std;


class Person
{
public:
   Person( const char * name = "" , int id = 0): _name(name), _num(id){}
protected:
   string _name; // 姓名
   int _num; // 身份证号
};
class Student: public Person
{
public :
    Student(const char * name, int id, int stuNum): Person(name , id ), _num(stuNum ){}
    void DisplayNum()
    {
       cout<<" 身份证号： "<<Person :: _num<< endl ;
       cout<<" 学号"<< _num << endl ;
    }
protected :
    int _num ; // 学号
};

5.继承与转换（赋值兼容规则，必须为public继承）

子类对象可以赋值给父类对象——赋值的那部分是子类继承父类的部分

父类对象不能赋值给子类对象——程序会崩溃

父类的指针/引用可以指向子类对象

子类的指针/引用不能指向父类对象（可以通过强制类型转换完成）

//指向基类的指针
class Base
{
public:
	void show()
	{
		cout<<"基类的函数成员show（）\n"<<endl;
	}

	int _b;
};

class Derived:public Base
{
public:
	void show()
	{
		cout<<"子类的函数成员show（）\n"<<endl;
	}
	int _d;

};


int main()
{
	Base *b;
	Derived d;
//	d._d = 2;
//	Base base;
//	base._b = 4;
//	base = d;    //(子类对象赋值给基类对象)
//	d = base;    //(基类对象不能赋值给子类对象)
	
//	b = &d;      //(基类指针指向子类对象)
	b->show();   //(通过基类指针所访问的成员仍然是基类成员)

	system("pause");
	return 0;
}

6.友元关系不能继承，也就是说基类友元不能访问子类私有和保护成员。

7.继承与静态成员：基类定义了static成员（可以被继承），则整个继承体系里面只有一个这样的成员。无论派生出多少子类，都只有一个static成员实例。

二、单继承&多继承&菱形继承

1.单继承

一个子类只有一个直接父类。

2.多继承

一个子类有两个或以上直接父类时称这个继承关系为多继承

3.菱形继承

//菱形继承
class Base  //基类
{
public:
	Base()
	{
		cout<<"Base()"<<endl;
	}

	~Base()
	{
		cout<<"~Base()"<<endl;
	}

	int _b;
	
};

class C1:public Base   //派生类
{
public:
	C1()
	{
		cout<<"C1()"<<endl;
	}
	
	~C1()
	{
		cout<<"~C1()"<<endl;
	}

	int _c1;

};

class C2:public Base   //派生类
{
public:
	C2()
	{
		cout<<"C2()"<<endl;
	}
	
	~C2()
	{
		cout<<"~C2()"<<endl;
	}

	int _c2;

};


class D:public C1,public C2  //派生类
{
public:
	D()
	{
		cout<<"D()"<<endl;
	}
	
	~D()
	{
		cout<<"~D()"<<endl;
	}

	int _d;

};
void FunTest1()
{
	//Base b;
	D d;
//d._b = 0;
	d._c1 = 1;
	d._c2 = 2;
	d._d = 3;
}

int main()
{
	FunTest1();

	system("pause");
	return 0;
}

菱形继承的二义性：

4.虚继承（解决菱形继承的二义性和数据冗余的问题）