C++ 继承和派生

简单来说：有两个类A和B，A是父类，B是子类。那么就可以说：A派生出B，B继承与A。

例：
父亲 “派生” 出儿子
儿子 “继承” 自父亲

派生和继承，本质是相同的，只是从不同角度来描述他们而已。

继承和派生在UML中的表示:

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

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

假如已经定义好了父类Father，里面定义好私有数据成员name和age，和公有的构造函数、成员方法description等。当子类Son要继承父类Father时，需要包含 ”父类的头文件“，定义方式如下：
公有继承方式

#include "Father.h"		// 包含父类的头文件

class Son : public Father {
	// 详细见下面全部代码
}

假如子类Son要调用自定义的重载构造函数是：
1.会先调用父类的构造函数，用来初始化父类继承的数据，
2.再掉用自己的构造函数，用来初始化自己定义的数据。

例：

Son::Son(const char *name, int age, const char *game) : Father(name, age) {
	// 没有体现父类的构造函数, 那就会自动调用父类的默认构造函数!!!
	
	this->game = game;	// 子类自己定义的数据成员
}

注意一：
子类的成员函数，不能访问从父类继承的private成员

例：
在子类Son中，this->name = name;或者 cout << age << endl;都是错误的。
但子类可以访问父类的成员函数，如 cout << getName() << getAge() << endl;都是正确的。

注意二：
子类对象调用方法时，现在自己定义的方法中去寻找，如果有，就调用自己定义的方法；如果找不到，就到父类的方法中去找，如果有，就调用父类的这个同名方法；如果在父类中找不到，就发生错误！

例：
父类和子类都定义了description方法，子类Son去调用这个方法，会优先在自己的方法里去找来调用，如果没有，再去父类里找；也没有的话就报错。

	Son son("王思聪", 32, "电竞");

	cout << son.description() << endl;

============================================================

继承和派生的简单说明完结，具体代码如下：

代码实现：

定义Father父类

#pragma once

#include <string>

using namespace std;

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

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

private:
	string name;
	int age;
};

Father类方法实现

#include <sstream>	// 不懂此类型，请看我另一篇博客介绍
#include "Father.h"

Father::Father(const char *name, int age) {
	this->name = name;
	this->age = age;
}

Father::~Father() {

}

string Father::getName() const {
	return name;
}

int Father::getAge() const {
	return age;
}

string Father::description() const {
	stringstream ret;	// 不懂此类型，请看我另一篇博客介绍

	ret << "姓名：" << name << " 年龄：" << age << endl;

	return ret.str();
}

定义Son子类

#pragma once

#include "Father.h"

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

	string getGame() const;
	string description() const;

private:
	string game;
};

Son方法实现

#include <sstream>	// 不懂此类型，请看我另一篇博客介绍
#include "Son.h"

// 创建Son对象时, 会调用构造函数!
// 会先调用父类的构造函数, 用来初始化从父类继承的数据 
// 再调用自己的构造函数, 用来初始化自己定义的数据
Son::Son(const char *name, int age, const char *game) : Father(name, age) {
	// 没有体现父类的构造函数, 那就会自动调用父类的默认构造函数!!!
	this->game = game;
}

Son::~Son() {

}

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

string Son::description() const {
	stringstream ret;	// 不懂此类型，请看我另一篇博客介绍
	
	/*	// 下面都是错误的
	this->name = name;
	this->age = age;
	cout << name << age << endl;
	*/
	
	// 子类的成员函数中, 不能访问从父类继承的private成员
	ret << "name:" << getName() << " age:" << getAge() << " game:" << game << endl;
	// 如果需要访问从父类继承下来的数据成员，就得把父类的private改成protected
	// 详情请看下面补充

	return ret.str();
}

main方法实现：

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

int main(void) {
	Father father("王健林", 68);
	Son son("王思聪", 32, "电竞");

	cout << father.description() << endl;

	// 子类对象调用方法时, 先在自己定义的方法中去寻找, 如果有, 就调用自己定义的方法
	// 如果找不到, 就到父类的方法中去找, 如果有, 就调用父类的这个同名方法
	// 如果还是找不到, 就是发生错误!
	cout << son.description() << endl;

	system("pause");
	return 0;
}

运行截图:

子类, 一般会添加自己的数据成员/成员函数,
或者, 重新定义从父类继承的方法!!! 子类对象就会调用自己重新定义的方法, 不会调用父类的同名方法

=

=

=

补充：
前面讲到，子类不能在自己的成员函数内访问从父类继承的private数据成员，假如有需求需要访问的话，那么，就得把父类的数据成员定义为protected形式的数据成员。

为什么要使用protected访问权限？

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

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

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

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

访问权限总结:
public
外部可以直接访问.
可以通过对象来访问这个成员
Father father(“王健林”, 65);
Father.getName();

private
外部不可以访问
自己的成员函数内, 可以访问
Father father(“王健林”, 65);
father.name; // 错误!!!
Father内的所有成员函数内, 可以直接访问name

protected
protected和private非常相似
和private的唯一区别:
protecte: 子类的成员函数中可以直接访问
private: 子类的成员函数中不可以访问

============================================================

Father类原本使用private定义的数据成员，现在把他改成protected

//private:
protected:
	string name;
	int age;

之后，在子类的成员函数中就可以直接访问从父类继承下来的protected数据成员了

string Son::description() const {
	stringstream ret;

	// 子类的成员函数中, 不能访问从父类继承的private成员
	//ret << "name:" << getName() << " age:" << getAge() << " game:" << game << endl;
	
	// 把父类的数据成员改成protected后，就可以直接访问了：
	ret << "name:" << name << "age" << age << "game" << game << endl;

	return ret.str();
}