14.7 子类、调用顺序、访问等级与函数遮蔽

一：派生类概念
类之间有一种层次关系，有父类，有孩子类。比如车这个类，当成父类(也叫基类，超类)，派生出卡车，轿车，他们属于孩子类(子类/派生类)

继承：有父亲类，有孩子类，构成了层次关系。继承这种概念，是面向对象程序设计的核心思想之一。
这种继承，就是我们要先定义一个父类。父类中定义一些公用的成员变量，成员函数。我们通过继承父类来构建新的类：子类。所以写代码时，只需写和子类相关的一些内容即可。子类一般会比父类更加庞大。

Human.h

#pragma once
#ifndef __HUMAN__
#define __HUMAN__
#include 
using namespace std;

class Human
{
public:
	Human();
	Human(int i);
public:
	int m_Age;
	char m_Name[100];
	void funcPub() {};
	void samenamefunc();
	void samenamefunc(int i);
	string samenamefunc(string s);
protected:
	int m_pro1;
	void funcPro() {};
private:
	int m_priv1;
	void funcPriv() {};
};
#endif // !__HUMAN__

Human.cpp

#include "Human.h"

Human::Human()
{
	cout << "Human::Human()" << endl;
}

Human::Human(int age)
{
	cout << "Human::Human(int age)" << endl;
}

void Human::samenamefunc()
{
	cout << "Human::samenamefunc()" << endl;
}

void Human::samenamefunc(int i)
{
	cout << "void Human::samenamefunc(int i)" << endl;
}

string Human::samenamefunc(string s)
{
	cout << "string Human::samenamefunc(string s)" << endl;
	return s;
}

Men.h

#pragma once
#ifndef __MEN__
#define __MEN__
#include "Human.h"

class Men:private Human
{
public:
	Men();
	using Human::samenamefunc;
public:
	void samenamefunc();
};


#endif // !__MEN__

Men.cpp

#include "Men.h"

Men::Men()
{
	cout << "Men::Men()" << endl;
}
void Men::samenamefunc()
{
	cout << "Men::samenamefunc()" << endl;
	//Human::samenamefunc();
	//Human::samenamefunc(100);
}

Test.cpp

#include 
#include "Men.h"
using namespace std;

int main()
{
	Men men;
	men.samenamefunc();
	men.samenamefunc(100);
	cin.get();
	return 0;
}

class Men :public Human。
class 子类名 ： 继承方式，父类名
继承方式(访问等级/访问权限)：public/protected/private;

二：派生类对象定义时调用构造函数的顺序

Men men;

父子类初始化谁先调用？当定义子类对象时，调用父类和子类的构造函数，且父类的构造函数体先执行，子类的构造函数体后执行。

三：public、protected、private

总结一下：三种访问权限

public：可以被任意实体所访问。
protected：只允许本类或者子类的成员函数来访问。
private：只允许本类的成员函数访问。

三种继承访问：
public 继承
protected 继承
private 继承

总结：

<1>子类public继承父类不改变父类的访问权限。
<2>protected继承将父类中public成员变为子类的protected成员。
<3>private继承使得父类所有成员在子类中的访问权限变为private。
<4>父类中的private成员不受继承方式的影响，子类永远无权访问。
<5>对于父类来讲，尤其是父类的成员函数，如果你不想让外边访问，就设置为private； 如果你想让自己的子类能够访问，就设置为protected，如果你想公开，就设置为public。

四、函数遮蔽

子类中如果有一个同名函数，那么父类中，不管有几个同名函数(不管是否带参数)，子类中都无法访问到。
如果我们确实想调用父类中的同名函数怎么办？
<1>在子类的成员函数中，用父类 "父类::函数名"强制调用父类函数。

void Men::samenamefunc()
{
	cout << "Men::samenamefunc()" << endl;
	Human::samenamefunc();
	Human::samenamefunc(100);
}

<2>using : using namespace
在 using c++11 中让父类同名函数在子类中可见。
通过 using 这个关键字，让父类的同名函数在子类中可见(让父类同名函数在子类中一重载的方式来使用)
说明：
<2.1>using Human::samenamefunc; 只能指定函数名，则凡是基类中public、protected的samenamefunc（基类中private不行）在子类中都可见。无法让一部分可见(函数重载全部可见)
<2.2>using 引入的主要目的是用来实现在子类中调用父类的重载版本。该函数在父类中的参数跟子类中的参数个数、类型不同。
Men men;
men.samenamefuc(12); 执行结果：执行了子类public::samenamefuc(int)的函数
men.samenamefuc();

class Men:private Human
{
public:
	Men();
	using Human::samenamefunc;
public:
	void samenamefunc();
};

注：
若使用“using Human::samenamefunc;”语句：
<1>using的基类方法不能有private重载，就算子类已重写的方法也不行，否则会报错。 >“Human”: 并非所有的重载都可访问
<2>使用“using Human::samenamefunc;”语句后，调用父类，可以使public、protected、private均不报错。但必须要有调用父类。