[C++学习实验2] 继承和多态

一、继承访问权限测试

1、概述
C++面向对象的三大特性为：封装、继承、多态

（1）设计类Person具有public, protected, private等不同属性的成员函数或变量；
（2）类Student，Teacher，worker通过public, protected, private等不同方式继承Person，在继承类的成员函数中测试访问父类Person的成员函数或变量；
（3）在继承类中添加public, protected, private等不同属性的成员函数或变量，在外部测试访问继承类的各个成员函数或变量；
（4）继承类worker以private方式继承Person，尝试把Person中的部分private成员提升为public。
 

我们在设计类的时候，可以把属性和行为（成员变量和函数）放在不同的权限下

访问权限有三种：

     public   公共权限    类内可以访问，类外也可以访问
     protected   保护权限   类内可以访问，类外不可以访问
     private   私有权限  类内可以访问，类外不可以访问
其中

     private是完全私有的，只有自己可以访问，派生类和外部都不可以访问。
     protected是受保护的，只有派生类可以访问，外部不能访问。
同时 

       保护继承（protected）：如果继承方式为保护继承，基类的公有和保护成员将成为派生类的保护成员。
       私有继承（private）：如果继承方式为私有继承，基类的公有和保护成员将成为派生类的私有成员。

（1）继承方式：基类成员在派生类中的访问权限不得高于继承方式中指定的权限。

（2）子类可以访问父类的public和protected，外部只能访问public。不管继承方式如何，基类中的 private 成员在派生类中始终不能使用（不能在派生类的成员函数中访问或调用）。
（3）通过using 父类::成员;使用 using 关键字可以改变基类成员在派生类中的访问权限，例如将 public 改为 private、将 protected 改为 public。放于派生类中的public就改变为public，放在protected和private中同理。可升可降。

注意：using 只能改变基类中 public 和 protected 成员的访问权限，不能改变 private 成员的访问权限，因为基类中 private 成员在派生类中是不可见的，根本不能使用，所以基类中的 private 成员在派生类中无论如何都不能访问。

class worker :private Person
{
public:
	using Person::m_strName;//升级为public，外部可以访问
	using Person::m_strSex;
	//using Person::m_Age; no,原因：没有访问基类private的权限
	void Set()
	{
		m_strName = "";
		m_strSex = "";
		//m_Age = "";private不可访问
	}
	int w1;
protected:
	using Person::m_strSex;//外部依旧无法访问，因为外部只能访问public部分，所以应该放在public中
	int w2;
private:
	int w3;
};

其中，worker通过private的方式继承，通过using可以使m_strSex变为public，实际上是因为m_strSex在父类中是protected，子类可以访问父类的protected和public，所以显而易见，using Person::m_Age就是不可行的，因为m_Age在父类中是private，子类没有访问父类中private的权限。
 

 2、代码实现
①main.cpp

#include <iostream>
#include "person.h"
using namespace std;

int main()
{
	Person p;
	p.m_strName;
	//p.m_strSex; 都不能访问，外部访问只能访问public
	//p.m_Age

	Student s;
	s.m_strName;
	//s.m_strSex;无法访问
	//s.m_Age;
	s.s1;
	//s.s2;无法访问
	//s.s3

	Teacher t;
	t.m_strName;//通过protected继承后，成员函数和变量都降级为protected，原本无法访问，但是可以通过using 父类::成员;语句改写为公有
	t.m_strSex;
	//t.m_Age; 无法访问
	t.t1;
	//t.t2;无法访问
	//t.t3;

	worker w;
	w.m_strName;//升级为public，外部可以访问
	//w.m_strSex; 
	//w.m_Age
	return 0;
}

②person.h

#pragma once
#ifndef PERSON_H
#define PERSON_H
#include<string>
using namespace std;

//设计类Person具有public, protected, private等不同属性的成员函数或变量
class Person
{
public:
	Person();
	string m_strName;
protected:
	string m_strSex;
	void SetSex(string strSex = "")
	{
		m_strName = "";
		m_strSex = strSex;
	}
private:
	int m_Age;
};

//类Student通过public方式继承Person，测试访问Person的成员函数和变量
class Student :public Person  //继承下来级别都为不变，只能降级不能升级
{
public:
	//内联函数不能放在cpp文件中
	//隐式内联函数
	void SetSex(string strSex = "")//无论继承方式是什么，都可以访问到protected以上的变量和成员函数
	{
		m_strName = "";   //内部能访问父类的protected以上的变量和成员函数，外部main只能访问public
		m_strSex = strSex;  
		//m_Age = ""；private不可访问
	}
	string GetSex();
	int s1;
protected:
	int s2;
private:
	int s3;
};

//类Teacher通过protected方式继承Person，测试访问Person的成员函数和变量
class Teacher :protected Person //函数和变量级别都变为protected
{
public:
	//可以把protected都变为public
	using Person::m_strName;
	using Person::m_strSex;
	//using Person::m_Age; 私有的不能升级
	void SetSex(string strSex = "")//父类子类中都有，main中调用是调用子类的，但是无法调用protected中的函数
	{
		m_strName = "";
		m_strSex = strSex;
		//m_Age = "";private不可访问
	}
	string GetSex()
	{
		return m_strSex;
	}
	int t1;
protected:
	int t2;
private:
	int t3;
};

//类worker通过private方式继承Person，测试访问Person的成员函数和变量
class worker :private Person
{
public:
	using Person::m_strName;//升级为public，外部可以访问
	void Set()
	{
		m_strName = "";
		m_strSex = "";
		//m_Age = "";private不可访问
	}
	int w1;
protected:
	using Person::m_strSex;//外部依旧无法访问，因为外部只能访问public部分，所以应该放在public中
	using Person::m_strSex;
	//using Person::m_Age; no,原因：没有访问基类private的权限
	int w2;
private:
	int w3;
};

//显式内联函数
in