[C++知识库]C++学习之路—面向对象—继承

什么叫类的继承特性

C++中类的继承特性指的是子类继承父类的成员的一种特性。一旦子类合理的继承了某个父类，就可以直接使用其内部的成员，避免重新添加成员，可减少代码量，增加程序的可读性。
继承的写法如下：Parent类是父类，Children是子类。

class Parent{

};

class Children : public Parent
{

};

为什么要有C++的继承特性

比如student和worker都有Person的一些性质，比如都有年龄属性、都有吃饭功能，但student会study，worker会work一些个性功能。

class Student
{
public:
	int m_age;//共性
	int m_score;//个性

	void eat() { }//共性
	void exam() { }//个性

};

class Worker
{
public:
	int m_age;//共性
	int m_salary;//个性

	void eat() { }//共性
	void work() { }//个性
};

那就把共性提取出来设置为父类。让student和worker继承Person，就可以减少代码量，程序的可读性也更高。

class Person
{
public:
	int m_age;//共性
	void eat() { }//共性
};

class Student : public Person
{
public:
	int m_score;//个性
	void exam() { }//个性
};

class Worker : public Person
{
public:
	int m_salary;//个性
	void work() { 
		cout << m_age << endl;
	}//个性
};

这个简单的实例程序说明了一个这样的事实：C++的继承特性可以提高程序的"可复用性"。这种可复用性表现在子类可以调用父类的函数和成员。（记住一句话：继承就是直接把父类的东西复制粘贴在子类里）

子类调用父类的成员

由于Worker继承了Person类，所以可以访问Person中的m_age成员，说白了Person中的成员就是Worker的成员（父类的成员也是子类的成员）

int main(void)
{
	Worker worker;
	worker.m_age = 10;
	worker.work();//打印10

	getchar();
	return 0;
}

继承规则

正因为继承太有用，也太容易用，所以必须要防止乱用。我们应当给继承设置一些规则。

规则1

如果类A和类B基本上毫不相关，不可以为了让类B的功能更多一点而强行继承类A。不要有那种"不吃白不吃的想法"

规则2

若在逻辑上B是A的某一个特例，或者说B是A的一种，则类B最好继承类A。

例如男人(Man)是人(Person)的一种，男孩(Boy)又是男人(Man)的一种。那么类Man可以从类Person中派生，类Boy可以从类Man中派生。

class Person	 //Person是基类   
{
public:
	int m_age;
	...
};

class Man : public Person	 //Man是Person的派生类 
{
public:
	int short_hair;
 	...
};

class Boy : public Man	   //Boy是Man的派生类 
{
public:
	int small_height;
	...
};

在这里顺便唠叨一句继承时，继承时的内存布局问题。首先Boy上面有父类和所谓的‘爷爷类’，假设每个类里目前存有一个int型的变量。那么Boy类所占内存是多少呢？答案肯定是4*3=12，因为继承其实就是复制粘贴父类的成员到子类中。
那当我创建Boy对象时，内存里的变量是怎么排布的呢(地址)？答案是m_age在Boy对象内存区的顶端，占4个字节，然后是short_hair，最后是small_height。

多重继承

如果一个类同时具有另外几个类的属性（多重属性），在程序世界该如何表达它呢？C++有办法，那就是使用多重继承。

例如，我们家中经常使用的沙发床，它既有沙发的属性（人可就座），也有床的属性（人可躺下），所以沙发床就同时继承沙发和床，那程序中如何表示呢？

class Sofa	    
{
public:
	void Setting(Man&);	//人可就座
};

class Bed	   
{
public:
	void Lying(Man&);//人可躺下
};

class SofaBed : public Sofa , public Bed
{
public:
	void Setting(Man&);	//人可就座
	void Lying(Man&);//人可躺下
};

从上述可以看出，一个子类可以继承多个父类，只需要用逗号隔开。

成员访问权限

我们知道成员访问权限有三种，分别是：

• public：公共的，任何地方都可以访问（struct默认所有成员都是public）
• protected：受保护的，子类内部和当前类内部可以访问，但是外部不可以访问
• private：私有的，只能在当前类内部访问，子类和外部都不可访问（class默认所有成员都是private）

那么继承方式也存在三种，下方代码说明了不同的继承方式的书写：

class Person
{
public:
	//公共的

private:
	//私有的

protected:
	//受保护的
};

class Student : public Person//public继承
{
};
class Student : private Person//private继承
{
};
class Student : protected Person//protected继承
{
};

现在讲讲三种继承方式的区别。开始之前要知道三种访问权限的大小，public > protected > private。子类继承方式与父类中的访问权限作and，取访问权限最小的那个，作为子类继承的结果。

• public方式继承

class Person
{
public:
	//公共的
	int public_member;
	
private:
	//私有的，如果子类继承，是不可以访问的
	int private_member;

protected:
	//受保护的，子类继承是可以访问的
	int protected_member;
};

class Student : public Person//public继承
{
//继承过来相当于这样，与不同的访问权限作and，取访问权限最小的那个
public and public = public:
	//继承结果是公共的，子类内部，外部都可访问
	int public_member;

private and public = private:
	//继承结果是私有的，子类的内部仍然不可访问
	int private_member;

protected and public = protected:
	//继承结果是受保护的，子类内部可以访问，但是外部不可访问（比如说main函数里）
	int protected_member;
};

• private方式继承

class Person
{
public:
	//公共的
	int public_member;

private:
	//私有的
	int private_member;

protected:
	//受保护的
	int protected_member;
};

class Student : private Person//private继承
{
//继承过来相当于这样，与不同的访问权限作and，取访问权限最小的那个
public and private = private :
	//继承结果是私有的，由于父类是public，所以当前类可以访问，
	//但是如果还有当前类的子类，就不可以访问了，因为经过当前类，已经变成私有的了
	int public_member;

private and private = private:
	//继承结果是私有的，由于父类就是私有的，所以子类的内部自然不可访问
	int private_member;

protected and private = private :
	//继承结果是私有的，由于父类是protected，所以当前类可以访问，
	//但是如果还有当前类的子类，就不可以访问了，因为经过当前类，已经变成私有的了
	int protected_member;
};

可以看出private继承方式，曾经在父类中的public和protected经过继承都不可以直接在类外访问了，如果想要在外部用到这些，就需要使用public下的setter和getter方法了。这种继承方式并不是是无意义的哦。

• protected继承方式

class Person
{
public:
	//公共的
	int public_member;

private:
	//私有的
	int private_member;

protected:
	//受保护的
	int protected_member;
};

class Student : protected Person//protected 继承
{
//继承过来相当于这样，与不同的访问权限作and，取访问权限最小的那个
public and protected = protected :
	//继承结果是受保护的，由于父类是public，所以当前类可以访问，
	//如果还有子类，其内部也是可以访问，因为经过当前类这块变成了protected
	//外部不可访问（比如说main函数里）
	int public_member;

private and protected = private:
	//继承结果是私有的，子类的内部仍然不可访问
	int private_member;

protected and protected = protected :
	//继承结果是受保护的，由于父类是protected，所以当前类可以访问，
	//但是如果还有子类，其内部也是可以访问，因为经过当前类这块变成了protected
	//外部不可访问（比如说main函数里）
	int protected_member;
};

我们可以看出，只有当继承方式为public时，赋予子类的访问权限与父类一致。所以我们以后用到继承时，统统采用public继承方式。这样的话父类访问权限怎样，子类的访问权限就是怎样，防止出错。
如果我们在使用继承时，忘了规定继承方式，那默认是哪种继承方式呢？

class Student : Person//private继承
{
};

struct Student : Perosn//public继承
{
};

这与class和struct创建类时，默认成员的访问权限是一致的。

C++继承总结要点

• C++的继承很简单，就是子类把父类的所有成员复制到自己的类下，就是"复制的感觉"。
• 子类想要访问父类的成员，取决于父类的成员权限和子类的继承方式，但我们用public继承时，就值取决于父类的成员权限。
• 子类继承父类的private成员时，即使无法访问，但也会继承下来，也会占用内存空间。
• 使用继承时，要好好设计类，要做到合理继承。