继承与派生

继承和派生在UML中的表示

假如以人类、男人类、女人类为例子。

注意是“空心三角箭头”，从子类【派生的类】指向父类【被继承的类】
父类，也称为“基类”。

除了“构造函数”和“析构函数”，
父类的所有成员函数，以及数据成员，都会被子类继承！

派生和继承的实现

父类：

class Father
{
public:
	Father(const char*name, int age);
	~Father();

	string getName();
	int getAge();
	string description();

private:
	int age;
	string name;
};

子类：

#include "Father.h"

class Son : public Father {
public:
	Son(const char *name, int age, const char *game);
	~Son();
	string getGame();
	string description();
private:
	string game;
};

#include "Son.h"
#include <iostream>
#include <sstream>

// 创建Son对象时, 会调用构造函数!
// 会先调用父类的构造函数, 用来初始化从父类继承的数据 
// 再调用自己的构造函数, 用来初始化自己定义的数据
Son::Son(const char *name, int age, const char *game) : Father(name, age) {
	cout << __FUNCTION__ << endl;

	// 没有体现父类的构造函数, 那就会自动调用父类的默认构造函数!!!
	this->game = game;
}

Son::~Son() {

}

string Son::getGame() {
	return game;
}

string Son::description() {
	stringstream ret;
	// 子类的成员函数中, 不能访问从父类继承的private成员
	ret << "name:" << getName() << " age:" << getAge()
		<< " game:" << game;
	return ret.str();
}

注意：
子类对象调用方法时, 先在自己定义的方法中去寻找, 如果有, 就调用自己定义的方法；如果找不到, 就到父类的方法中去找, 如果有, 就调用父类的这个同名方法，如果还是找不到, 就是发生错误!
子类, 一般会添加自己的数据成员/成员函数, 或者, 重新定义从父类继承的方法!!! 子类对象就会调用自己重新定义的方法, 不会调用父类的同名方法。

派生类（子类）对象的内存分布

**说明：**成员函数，不占用对象的内存空间，但是也被子类继承了！！！

protected（保护）访问权限

子类的成员函数中，不能直接访问父类的private成员，虽然这些成员已经被继承下来了，但是却不能访问。
只有通过父类的public函数来间接访问，不是很方便。
比如，刚才Demo中Father类中的name和age成员。

解决方案：
把name和age定义为protected访问访问权限。

效果：
Son类的成员函数中，可以直接访问它的父类的protected成员。
但是在外部，别人又不能直接通过Son对象来访问这些成员。

一个类, 如果希望它的成员, 可以被自己的子类(派生类)直接访问,
但是, 又不想被外部访问那么就可以把这些成员定义为 protected访问权限!!!

访问权限总结:
public
外部即对象，可以直接访问.
private
外部即对象，不可以访问
自己的成员函数内, 可以访问
Father内的所有成员函数内, 可以直接访问name
protected
protected和private非常相似
和private的唯一区别:
protected: 子类的成员函数中可以直接访问
private: 子类的成员函数中不可以访问

派生和继承的各种方式

public（公有）继承 [使用最频繁]
父类中定义的成员（数据成员和函数成员）被继承后，访问权限不变！
public --> public
protected --> protected
private --> private

private（私有）继承
父类中定义的成员（数据成员和函数成员）被继承后，访问权限都变成private
public --> private
protected --> private
private --> private

protected（保护）继承
public --> protected
protected --> protected
private --> private

小结：
public 继承全不变
private继承全变私
protected继承只把public降级为protected

什么时候使用继承和派生

1） 准备实现多个类，但是这些类在现实世界中有某种特殊关系（比如：类别与子类别的关系）
例如：人 女人 男人
如果完全独立的实现这3个类，将有很多重复代码，而且不利于以后的维护。

2）准备构建一个类，但是这个类与已经开发好的某个类非常相似，而且在现实世界中具有某种特殊关系（比如：类别与子类别的关系）。
如果全部重新写这个新类，效率较低，因为有很多东西已经在这个已有的类中实现了。

3）对多个已经实现的类（这些类有某种特殊关系），进行重构。
一般在前两种情况使用，第3种（重构）是不得而为之。

子类调用父类构造函数顺序

注意：在子类的构造函数中，显式调用父类的构造函数，如果没有显式的调用父类的构造函数，那么会自动调用父类的默认构造函数。

当创建子类对象时, 构造函数的调用顺序：
静态数据成员的构造函数 -> 父类的构造函数 -> 非静态的数据成员的构造函数 -> 自己的构造函数

注意:
无论创建几个对象, 该类的静态成员只构建一次, 所以静态成员的构造函数只调用1次!!!

class M {
public:
	M() {
		cout << __FUNCTION__ << endl;
	}
};

class N {
public:
	N() {
		cout << __FUNCTION__ << endl;
	}
};

class A {
public:
	A() {
		cout << __FUNCTION__ << endl;
	}
};

class B : public A {
public:
	B() {
		cout << __FUNCTION__ << endl;
	}
private:
	M m1;
	M m2;
	static N ms;
};

N B::ms;  //静态成员
int main(void) {
	B b;
	system("pause");
}

执行顺序，从上到下即为先后顺序：
N::N 静态数据成员的构造函数
A::A 父类的构造函数
M::M 非静态数据成员的构造函数
M::M 非静态数据成员的构造函数
B::B 自己的构造函数

**注意：**子类的析构函数的调用顺序，和子类的构造函数的调用顺序相反！！！

静态对象在程序终止时被销毁，所以：静态成员的析构函数，在程序结束前，是不会被调用的！