C++入门之——【 继承 】

简介： “继承”就是在已存在的类的基础上建立一个新的类。 已存在的类称为“基类”或者“父类”，新建的类称为“派生

类”或“子类”。是面向对象程序设计使代码可以复用的最重要的手段，它允许程序员在保持原有类特性的基础上进行扩展，增加功能。

方式：   public: 基类访问权限保持不变

   private:基类的公有成员和保护成员称为派生类的私有成员

         protected:

                三种方式的比较：

继承的定义格式：

class 派生类：继承类型（public/private/protected）基类名

分类：

单继承：      从一个基类派生的继承称为单继承

举例：

                                                                                                                 

class Base
{
public:
	Base(int b = 0)
		:_b(b)
	{

	}
	void display()
	{
		cout << "Base:display()" << endl;
	}
private:
	int _b;
};
class Derived :public Base  //Derived 是Base的公有派生类，Base 是Derived 的基类
{
public:
	Derived(int d = 0)
		:_d(d)
	{

	}
	void display()
	{
		cout << "Derived::display()"<< endl;
	}
private:
	int _d;
};

多继承 ：  从多个基类派生的继承称为多继承。

举例：

                                     

class Base1
{
public:
	Base1(int ba = 0)
		:_ba(ba)
	{

	}
	void display()
	{
		cout << "Base1:display()" << endl;
	}
private:
	int _ba;
};
class Base2
{
public:
	Base2(int b = 0)
		:_b(b)
	{

	}
	void display()
	{
		cout << "Base2:display()" << endl;
	}
private:
	int _b;
};
class Derived :public Base1,protected Base2 // Derived 公有继承Base1,保护继承Base2
{
public:
	Derived(int d = 0)
		:_d(d)
	{

	}
	void display()
	{
		cout << "Derived::display()"<< endl;
	}
private:
	int _d;
};

菱形继承 ：两个子类继承同一个父类，而又有子类同时继承这两个子类（多继承的一种特殊情况）

举例：

                  

class A
{
public:
	A(int a=0)
		:_a(a)
	{

	}
	void display()
	{
		cout << "A:display()" << endl;
	}
private:
	int _a;
};
class Base1: public A
{
public:
	Base1(int ba = 0)
		:_ba(ba)
	{

	}
	void display()
	{
		cout << "Base1:display()" << endl;
	}
private:
	int _ba;
};
class Base2: public A
{
public:
	Base2(int b = 0)
		:_b(b)
	{

	}
	void display()
	{
		cout << "Base2:display()" << endl;
	}
private:
	int _b;
};

class C:public Base1, public Base2
{
public:
	C(int c = 0)
		:_c(c)
	{

	}
	void display()
	{
		cout << "C:display()" << endl;
	}
private:
	int _c;
};

这里出现一个问题：当我想调用A类中的display函数，调用不了！为什么呢？

解析:   Base1继承A，那么Base1里面肯定包含属于A的部分（）；Base2也同样如此。我在调用A中的display函数，就会产生  到底调用哪个类中函数呢，所以系统会给出调用不明确的错误。

就觉上面的问题（菱形继承的二义性和数据冗余的问题），就会谈到虚继承

虚继承

概述：

为了解决从不同途径继承来的同名的数据成员在内存中有不同的拷贝造成数据不一致问题，将共同基类设置为虚基类。这时从不同的路径继承过来的同名数据成员在内存中就只有一个拷贝，同一个函数名也只有一个映射。

虚继承使用：

class 派生类名：virtual 继承方式  基类名

virtual是关键字，声明该基类为派生类的虚基类。

注意：
1、在多继承情况下，虚基类关键字的作用范围和继承方式关键字相同，只对紧跟其后的基类起作用。

2、声明了虚基类之后，虚基类在进一步派生过程中始终和派生类一起，维护同一个基类子对象的拷贝。

虚基类：当在多条继承路径上有一个公共的基类，在这些路径中的某几条汇合处，这个公共的基类就会产生多个实例(或多个副本)，若只想保存这个基类的一个实例，可以将这个公共基类说明为虚基类。

虚继承语法使用：

class 派生类: virtual 基类1，virtual 基类2，...，virtual 基类n

{

...//派生类成员声明

};

举例说明：

class A
{
public:
	A(int a=0)
		:_a(a)
	{

	}
	void display()
	{
		cout << "A:display()" << endl;
	}
private:
	int _a;
};
class Base1:virtual public A    //虚继承       A为虚基类
{
public:
	Base1(int ba = 0)
		:_ba(ba)
	{

	}
	void display()
	{
		cout << "Base1:display()" << endl;
	}
private:
	int _ba;
};
class Base2 :virtual public A //虚继承       A为虚基类

{
public:
	Base2(int b = 0)
		:_b(b)
	{

	}
	void display()
	{
		cout << "Base2:display()" << endl;
	}
private:
	int _b;
};

class C :virtual public Base1,virtual public Base2   //虚继承  Base1、Base2是虚基类
{
public:
	C(int c = 0)
		:_c(c)
	{

	}
	void display()
	{
		cout << "C:display()" << endl;
	}
private:
	int _c;
};

测试：

int main()
{
	C c(1);
	c.A::display();
	return 0;
}

结果：

 调用成功！