c++三大特性 封装、继承、多态 （一）

一. 封装

封装的定义

• 数据和方法放到一起，把像访问定义成公有、不想访问定义成私有和保护
• 一个类型放到另一个类型里面，通过typedef成员函数调整，封装另一个全新的类型

二.继承的概念及定义

2.1继承的概念

继承(inheritance)机制是面向对象程序设计使代码可以复用的最重要的手段，它允许程序员在保持原有类特性的基础上进行扩展，增加功能，这样产生新的类，称派生类。继承呈现了面向对象程序设计的层次结构，体现了由简单到复杂的认知过程。以前我们接触的复用都是函数复用，继承是类设计层次的复用

class Person
{
public:
 void Print()
 {
 cout << "name:" << _name << endl;
 cout << "age:" << _age << endl;
 }
protected:
 string _name = "peter"; // 姓名
 int _age = 18;  // 年龄
};
// 继承后父类的Person的成员（成员函数+成员变量）都会变成子类的一部分。这里体现出了
Student和Teacher复用了Person的成员。下面我们使用监视窗口查看Student和Teacher对象，可
以看到变量的复用。调用Print可以看到成员函数的复用。
class Student : public Person
{
protected:
 int _stuid; // 学号
};

class Teacher : public Person
{
protected:
 int _jobid; // 工号
};
int main()
{
 Student s;
 Teacher t;
 s.Print();
 t.Print();
 return 0;
}

2.2继承的定义

2.2.1 定义格式

2.2.2 继承关系和访问限定符

2.2.3 继承基类成员访问方式的变化

• 使用关键字class时默认的继承方式是private，使用struct时默认的继承方式是public，不过最好显示的写出继承方式。
• 基类private成员在派生类中是不能被访问，如果基类成员不想在类外直接被访问，但需要在派生类中能访问，就定义为protected。可以看出保护成员限定符是因继承才出现的

class Person
{

public:
	void Print()
	{
		cout << "name:" << _name << endl;	
		cout << "age:" << _age << endl;
	}

//protected:
	string _name = "peter";
private:
	int _age = 18;
};

class Student :public Person
{

public:
	void func()
	{
		cout << _name << endl;
		//不能直接访问父类私有成员
		//cout << _age << endl;

		//可以间接使用
		Print();
	}
protected:
	int _stuid;

};

class Teacher : public Person
{
protected:
	int _jobid;
};

int main()
{
	Student s;
	Teacher t;

	//需要把protect注释
	//s._name += "s";//这里变成保护，访问不了name
	//s._age += 3;

	//s.print();
	//t.print();
	return 0;
}

三.基类和派生类对象赋值转换

• 派生类对象 可以赋值给 基类的对象 / 基类的指针 / 基类的引用。这里有个形象的说法叫切片或者切割。寓意把派生类中父类那部分切来赋值过去。
• 基类对象不能赋值给派生类对象。
• 基类的指针或者引用可以通过强制类型转换赋值给派生类的指针或者引用。但是必须是基类的指针是指向派生类对象时才是安全的

int main()
{
	int i = 1;
	double d = i;
	const string& s = "1111";

	//不相关类型 不支持
	//string str = (string)i;//强转也不可以
	
	//切割/切片赋值兼容   不产生临时对象
	Student st;
	Person p=st;///只共有继承才可以
	Person& ref = st;
	Person* ptr = &st;

	ref._name += 'x';
	ptr->_name += 'y';
	
	return 0;
}

四.继承中的类作用域

• 在继承体系中基类和派生类都有独立的作用域
• 子类和父类中有同名成员，子类成员将屏蔽父类对同名成员的直接访问，这种情况叫隐藏，也叫重定义。（在子类成员函数中，可以使用 基类::基类成员 显示访问）
• 需要注意的是如果是成员函数的隐藏，只需要函数名相同就构成隐藏。
• 注意在实际中在继承体系里面最好不要定义同名的成员。

class Person
{

public:
	void Print()
	{
		cout << "name:" << _name << endl;	
		cout << "age:" << _age << endl;
	}

protected:
	string _name = "peter";

	int _age = 18;
	int _num=0;
};

class Student :public Person
{

public:
	void func()
	{
		//Student有两个_numm
		//默认访问子类
		cout << _num << endl;	

		//就想访问父类的
		cout << Person::_num << endl;
	}
protected:
	int _stuid;
	int _num=1;
};

int main()
{
	Student st;
	st.func();
	return 0;
}

加上域作用限定符即可访问父类的成员变量

函数重载 ： 函数名相同参数不同
如果是成员函数 ，函数名相同就隐身，参数可同，可不同
父类成员当成一个整体的自定义类型
子类成员 ：内置类型不做处理，自定义类型调用默认构造