c++学习心得第二期 继承

一、继承

1、继承的基本语法

继承的好处：可以减少重复的代码
class A : public B;
A 类称为子类 或 派生类
B 类称为父类 或 基类
派生类中的成员，包含两大部分：
一类是从基类继承过来的，一类是自己增加的成员。
从基类继承过过来的表现其共性，而新增的成员体现了其个性。

#include<iostream>
#include<string>
using namespace std;

class Base{
public:
	void head()
	{
		cout <<"头部文件" << endl;
	}
	void bottom()
	{
		cout <<"底部文件" << endl;
	}
	void left()
	{
		cout <<"导航栏" << endl;
	}
	virtual void content() = 0;
};

class Java:public Base{
public:
	void content()
	{
		cout <<"java" << endl;
	}

};
class Php :public Base{
public:
	void content()
	{
		cout <<"php" << endl;
	}

};
void test01()
{
	Java java;
	java.head();
	java.left();
	java.content();
	java.bottom();
	cout <<"------------------>" << endl;
	Php php;
	php.head();
	php.left();
	php.content();
	php.bottom();

}
int main()
{
	test01();
	system("pause");
	return 0;
}

2、继承方式

继承的语法：class 子类 : 继承方式 父类
继承方式一共有三种：
公共继承
保护继承
私有继承

#include<iostream>
#include<string>
using namespace std;
class Base1{

public:
	int m_A;
protected:
	int m_B;
private:
	int m_C;
};

//公共继承 父类什么权限 子类均为什么权限  父类的私有权限继承不到
class son1 :public Base1{
public:
	void func()
	{
		m_A;//公共权限
		m_B;//保护权限
		//m_C; 不能访问 为私有权限
	}
};
void tets01()
{
	son1 s1;
	s1.m_A;//只能访问到公共权限 m_A;
}
//保护继承 父类的公共权限变为保护权限，保护权限不变。 父类私有权限访问不到
class son2 :protected Base1{
public:

	void func(){
		//m_A和m_B均为 保护权限
		m_A;
		m_B;
		//m_C为私有权限
		//m_C;
	}
};
void test02()
{
	son2 s2;
	//均为保护权限，不可访问
	//s2.m_A;
	//s2.m_B;
}
//私有继承 父类的公共和保护权限均变为私有权限。父类私有权限访问不到
class son3 :private Base1{

public:
	void func()
	{
		m_A;
		m_B;
	}
};

void test03()
{
	son3 s3;
	//均为私有权限不可访问
	//s3.m_A;
	//s3.m_B;
}
class GrandSon3 :public son3{

	void func()
	{
		//son3 所有的成员变量均为私有权限，再有子类继承son3访问权限全部为私有，均不可访问。
		/*m_C;
		m_B;
		m_A;*/
	}
};
int main()
{

	system("pause");
	return 0;
}

3、继承中的对象模型

**问题：**从父类继承过来的成员，哪些属于子类对象中？

#include<iostream>
#include<string>
using namespace std;
class Base{

public:
	int m_A;
protected:
	int m_B;
private:
	int m_C;//私有成员是被隐藏了，但是还会被继承下去。
};
// 公共继承
class Son :public Base{
public:
	int m_D;
};
void test()
{
	//结果为16；
	cout <<"sizeof(Son)="<<sizeof(Son) << endl;
}
int main()
{
	test();
	system("pause");
	return 0;
}

打开工具窗口后，定位到当前CPP文件的盘符
然后输入： cl /d1 reportSingleClassLayout查看的类名 所属文件名

转入到相对应的盘符下

依次输入命令 类名 cpp的名字。可以看到类内部的成员变量。父类中的private属性依然继承，只是隐藏没有显现出来。
cl /d1

4、继承中构造和析构顺序

子类继承父类后，当创建子类对象，也会调用父类的构造函数
问题：父类和子类的构造和析构顺序是谁先谁后？

#include<iostream>
#include<string>
using namespace std;

class Base{
public:
	Base()
	{
		cout << "Base的构造函数"<< endl;
	}
	~Base()
	{
		cout << "Base的析构函数"<< endl;
	}
};
class Son :public Base{
public:
	Son()
	{
		cout <<"Son的构造函数" << endl;
	}
	~Son()
	{
		cout <<"Son的析构函数" << endl;
	}
};
void test01()
{
	//构造函数是先调用父类，再调用子类。
	//析构函数是先调用子类，再调用父类。
	Son s;
}
int main()
{
	test01();
	system("pause");
	return 0;
}

5、继承同名成员处理方式

问题：当子类与父类出现同名的成员，如何通过子类对象，访问到子类或父类中同名的数据呢？
访问子类同名成员 直接访问即可
访问父类同名成员 需要加作用域

子类对象可以直接访问到子类中同名成员
子类对象加作用域可以访问到父类同名成员
当子类与父类拥有同名的成员函数，子类会隐藏父类中同名成员函数，加作用域可以访问到父类中同名函数

#include<iostream>
#include<string>
using namespace std;

class Base{
public:
	Base()
	{
		m_A = 100;
	}
	void func()
	{
		cout <<"Base" << endl;
	}
	void func(int a)
	{
		cout <<"Base-int" << endl;
	}
public:
	int m_A;
};

class Son :public Base{
public :
	Son()
	{
		m_A = 200;
	}
	void func()
	{
		cout <<"son" << endl;
	}
public:
	int m_A;
};
void test01()
{
	Son s1;
	cout <<s1.m_A <<"200" <<endl;
	cout <<s1.Base::m_A <<"100"<< endl;

	//当子类与父类拥有同名的成员函数，子类会隐藏父类中所有版本的同名成员函数
	//如果想访问父类中被隐藏的同名成员函数，需要加父类的作用域
	s1.func();
	s1.Base::func();
	s1.Base::func(2);
}
int main()
{
	test01();
	system("pause");
	return 0;
}

6、继承同名静态成员处理方式

问题：继承中同名的静态成员在子类对象上如何进行访问？
静态成员和非静态成员出现同名，处理方式一致
访问子类同名成员 直接访问即可
访问父类同名成员 需要加作用域

同名静态成员处理方式和非静态处理方式一样，只不过有两种访问的方式（通过对象 和 通过类名）

#include<iostream>
#include<string>
using namespace std;

class Base{
public:
	
	static void func()
	{
		cout <<"Base" << endl;
	}
	static void func(int a)
	{
		cout <<"Base-int" << endl;
	}
public:
	static int m_A;
};
int Base :: m_A = 100;
class Son :public Base{
public :

	static void func()
	{
		cout <<"son" << endl;
	}
public:
	static int m_A;
};
int Son::m_A = 50;
//测试访问父类和子类静态成员变量
void test01()
{
	//实例化变量访问
	Son s;
	cout <<"son.m_A 50" <<s.m_A <<endl;
	cout <<"son.Base::m_A 100" <<s.Base::m_A << endl;
	//类名访问
	cout <<Son::m_A <<endl;
	cout <<Son::Base::m_A << endl;
}
//测试访问父类和子类静态成员函数
void test02()
{
	//实例化对象之后访问
	Son s;
	s.func();
	s.Base::func();
	s.Base::func(2);
	//通过类名进行访问
	Son::func();
	Son::Base::func();
	Son::Base::func(2);
}
int main()
{
	//test01();
	test02();
	system("pause");
	return 0;
}

7、 多继承语法

C++允许一个类继承多个类
语法： class 子类 ：继承方式 父类1 ， 继承方式 父类2…
多继承可能会引发父类中有同名成员出现，需要加作用域区分
C++实际开发中不建议用多继承

总结： 多继承中如果父类中出现了同名情况，子类使用时候要加作用域

#include<iostream>
#include<string>
using namespace std;

class Base1{
public:
	Base1(){
		m_A = 100;
	}
public:
	int m_A;
};
class Base2{
public :
	Base2()
	{
		m_A = 200;
	}
public:
	 int m_A;
};

class Son :public Base1, public Base2
{
public:
	Son()
	{
		m_C = 300;
		m_D = 400;
	}
public:
	int m_C ;
	int m_D;
};
//多继承容易产生成员同名的情况
//通过使用类名作用域可以区分调用哪一个基类的成员
void test01()
{
	Son s;
	cout << s.Base1::m_A << endl;
	cout << s.Base2::m_A << endl;
	cout <<s.m_C << endl;
	cout << s.m_D<< endl;
	cout << sizeof(Son) << endl;
	//size为16 包含两个A  和c d
	
}

int main()
{
	test01();
	system("pause");
	return 0;
}

8、菱形继承

​ 两个派生类继承同一个基类
又有某个类同时继承者两个派生类
这种继承被称为菱形继承，或者钻石继承

羊继承了动物的数据，驼同样继承了动物的数据，当草泥马使用数据时，就会产生二义性。

//使用虚继承处理菱形继承
#include<iostream>
#include<string>
using namespace std;
class Animal{

public:
	Animal()
	{
		age = 10;
	}
public:
	int age;

};
class sheep:virtual public Animal{};
class tuo :virtual public Animal{};
class sheeptuo :public sheep, public tuo{};
void test01()
{
	sheeptuo st;
	st.sheep::age = 20;
	st.tuo::age = 30;
	cout <<st.age << endl;
	cout << st.sheep::age << endl;
	cout << st.tuo::age << endl;
	cout << st.Animal::age << endl;

}
int main()
{
	test01();
	system("pause");
	return 0;
}

子类继承了两个指针（vbptr），两个指针指向同一个数据