# 继承与派生
1.什么是继承与派生
继承与派生相当于父亲与儿子一样，父亲将自己的东西派生给儿子，而儿子继承父亲的东西。
注：除了“构造函数”和“析构函数”，父类的所有成员函数，以及数据成员，都会被子类继承！
2.派生和继承的实现
分析：
Father.h
#pragma once
#include<string>
#include<iostream>
using namespace std;
class Father
{
public: //方法
//默认函数和析构函数不能被子类继承
Father(const char* name, int age);//const char*name 表示指针指向可以变，但是指向的内容不能变
~Father();
int getAge();
string getName();
string description();
private: //成员
int age;
string name;
};
Father.cpp
#include "Father.h"
#include<sstream>
#include<iostream>
Father::Father(const char* name, int age) {
cout <<"ABC" << endl;
this->name = name;
this->age = age;
}
Father::~Father() {
}
int Father::getAge() {
return age;
}
string Father::getName() {
return name;
}
string Father::description() {
stringstream des;
des << name << "-" << age << endl;
return des.str();
}
son.h
#pragma once
#include"Father.h" //继承父类的头文件
class son: public Father //继承父类的继承方式为public
{
public:
son(const char* name, int age, const char* game); //构造函数和默认函数不能继承父类，所以要自己定义
//const char*name 表示指针指向可以变，但是指向的内容不能变
~son();
string getGame();
string description();
private:
string game;
};
son.cpp
#include "son.h"
#include<iostream>
#include<sstream>
//创建son对象时，会调用构造函数！
//先调用父亲的构造函数。用来初始化从父亲继承的数据
//再调用自己的构造函数，用来初始化自己定义的数据
son::son(const char* name, int age, const char* game) : Father(name, age)
{
//没有体现父亲的构造函数，就会自动调用父亲的默认构造函数
cout << "A" << endl;
this->game = game;
}
son::~son()
{
}
string son::getGame()
{
return game;
}
string son::description()
{
stringstream des;
des << "name: " << getName() << "age；" << getAge() << "game" << game << endl;
//由于父类的name,age是私有的儿子继承了但是不能访问，但是可以访问父类的方法
//也可以将成员变成pretected
return des.str();
}
main.cpp
#include<iostream>
#include"Father.h"
#include"son.h"
int main() {
Father lsc("李白", 44);
son lhx("李小白", 22,"王者荣耀");
// 子类对象调用方法时, 先在自己定义的方法中去寻找, 如果有, 就调用自己定义的方法
// 如果找不到, 就到父类的方法中去找, 如果有, 就调用父类的这个同名方法
// 如果还是找不到, 就是发生错误!
cout << lsc.description() << endl;
cout << lhx.description() << endl;
system("pause");
return 0;
}
结果
ABC
ABC
A
李白-44
name: 李小白age；22game王者荣耀
注：子类, 一般会添加自己的数据成员/成员函数,
或者, 重新定义从父类继承的方法!!! 子类对象就会调用自己重新定义的方法, 不会调用父类的同名方法。
3.protected访问权限
1)、为什么要使用protected访问权限？
子类的成员函数中，不能直接访问父类的private成员，已经这些成员已经被继承下来了，但是却不能访问。
只有通过父类的public函数来间接访问，不是很方便。比如，前面案例Father类中的name和age成员。
解决方案：
把name和age定义为protected访问访问权限。
效果：
Son类的成员函数中，可以直接访问它的父类的protected成员。
但是在外部，别人又不能直接通过Son对象来访问这些成员。
使用情况：
一个类, 如果希望, 它的成员, 可以被自己的子类(派生类)直接访问,
但是, 又不想被外部访问那么就可以把这些成员, 定义为 protected访问权限!!!
2)、访问权限总结
public
外部可以直接访问. 可以通过对象来访问这个成员。
private
外部不可以访问、自己的成员函数内, 可以访问。
Fahter lb("王健林", 65);
lb.name; // 错误!!!
Father内的所有成员函数内, 可以直接访问name
protected
protected和private非常相似.
和private的唯一区别:
protected: 子类的成员函数中可以直接访问。
private: 子类的成员函数中不可以访问。
4.派生和继承的各种方式
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
5.什么时候使用继承和派生
1） 准备实现多个类，但是这些类在现实世界中有某种特殊关系（比如：类别与子类别的关系）
例如：人 女人 男人
如果完全独立的实现这3个类，将有很多重复代码，而且不利于以后的维护。
2）准备构建一个类，但是这个类与已经开发好的某个类非常相似，而且在现实世界中具有某种特殊关系（比如：类别与子类别的关系）。
如果全部重新写这个新类，效率较低，因为有很多东西已经在这个已有的类中实现了。
3）对多个已经实现的类（这些类有某种特殊关系），进行重构。
一般在前两种情况使用，第3种（重构）是不得而为之。
6.子类对父类成员的访问权限
无论通过什么方式（public、protected、private）继承，
在子类内部均可访问父类中的public、protected成员，
private成员不可访问（如果想要子类能够访问，就定义为protected）
继承方式只影响外界通过子类对父类成员的访问权限。
1)、public继承，父类成员的访问权限全部保留至子类；
2）、protected继承，父类public成员的访问权限在子类中降至protected；
3）、private继承，父类public、protected成员的访问权限在子类中均降至private。
7.调用父亲的那个构造函数
class Son : public Father {
public:
// 在子类的构造函数中，显式调用父类的构造函数
Son(const char *name, int age, const char *game)
:Father(name, age) {
this->game = game;
}
// 没有显式的调用父类的构造函数，那么会自动调用父类的默认构造函数
Son(const char *name, const char *game){
this->game = game;
}
};
8.子类和父类的构造函数的调用顺序
静态数据成员的构造函数 -> 父类的构造函数 -> 非静态的数据成员的构造函数 -> 自己的构造函数。
注意:
无论创建几个对象, 该类的静态成员只构建一次, 所以静态成员的构造函数只调用1次!!!
析构函数与之相反！！！！
