C++继承知识点

继承的基本语法

• 继承是面向对象的三大特性之一；
• 好处：将公共部分抽象出来，减少重复代码；
• 父类也称为基类，子类也称为派生类；
• 基本语法：class A:public B;
  class 子类：继承方式 父类

#include<iostream>
using namespace std;

//公共页面
class BasePage
{
public:
	void header()
	{
		cout << "首页  公开课" << endl;
	}
	void footer()
	{
		cout << "帮助中心" << endl;
	}
	void left()
	{
		cout << "分类" << endl;
	}
};

//Java页面
class Java:public BasePage  //继承公共页面
{
public:
	void content()
	{
		cout << "Java教学视频" << endl;
	}
};

//Python页面
class Python :public BasePage
{
public:
	void content()
	{
		cout << "Python教学视频" << endl;
	}
};
//C++页面
class Cpp :public BasePage
{
public:
	void content()
	{
		cout << "C++教学视频" << endl;
	}
};
void test1()
{
	cout << "Java教程视频如下：" << endl;
	Java ja;
	ja.header();
	ja.left();
	ja.content();
	ja.footer();
	cout << "-------------------------" << endl;

	cout << "Python教程视频如下：" << endl;
	Python py;
	py.header();
	py.left();
	py.content();
	py.footer();
	cout << "-------------------------" << endl;

	cout << "C++教程视频如下：" << endl;
	Cpp c;
	c.header();
	c.left();
	c.content();
	c.footer();
}

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

继承方式

• 公共继承
• 保护继承
• 私有继承
  

继承中的对象模型

从父类继承过来的成员，哪些属于子类对象中？
写个例子测试一下

#include<iostream>
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 test1()
{
	//父类中所以非静态成员属性都会被子类继承下去
	//父类中私有成员属性 是被编译器给隐藏了，因此是访问不到的，但是确实被继承下去了
	cout << "size of Son=" << sizeof(Son) << endl;
}

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

上例中父类中定义了三个int型变量，子类定义了一个int型变量，从运行结果可以看出子类继承父类后，会保留一份；

利用开发人员命令提示工具查看对象模型
1）开始菜单找到visual studio 中的开发人员名利提示符，双击打开；

2）查看上面编写的程序的文件路径，（或直接复制完整路径，可忽略下一步）

3）复制路径

4）回到开发人员命令提示符，输入cd+刚才复制的路径，进入到该文件夹

5）可以先使用dir命令查看当前目录下的文件

6）查看Son类的分布图

继承中的构造和析构顺序

• 子类继承父类后，当创建子类对象，也会调用父类的构造函数；
• 那么，父类和子类的构造和析构顺序是谁先谁后呢？

#include<iostream>
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 test1()
{
	//先构造父类，再构造子类，析构的顺序与构造的顺序相反
	Son s;
}

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

继承中，先调用父类构造函数，调用子类构造函数，析构的顺序与构造的顺序相反。

继承中同名成员处理方式

当子类与父类出现同名的成员，如何通过子类对象，访问到子类或父类中同名的数据呢？

• 访问子类同名成员，直接访问即可；
• 访问父类同名成员，需要加作用域；
• 当子类中出现和父类同名的成员函数，子类会隐藏父类中所有同名成员函数，加作用域可以访问到父类中同名函数。

1）同名的成员属性

#include<iostream>
using namespace std;

//父类
class Base
{
public:
	Base()
	{
		m_A = 100;
	}
	int m_A;
};

//子类
class Son :public Base
{
public:
	Son()
	{
		m_A = 200;
	}
	int m_A;
};

void test1()
{
	Son s;
	cout << "子类中m_A=" << s.m_A << endl;//直接访问的是子类中的m_A
	//如果通过子类对象，访问到父类中的同名成员，需要加作用域
	cout << "父类中m_A=" << s.Base::m_A << endl;

}

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

2）同名的成员函数

#include<iostream>
using namespace std;

//父类
class Base
{
public:
	Base()
	{ }
	void fun()
	{
		cout << "Base的fun函数" << endl;
	}
};

//子类
class Son :public Base
{
public:
	Son()
	{ }
	void fun()
	{
		cout << "Son的fun函数" << endl;
	}
};

void test1()
{
	Son s;
	//直接调用 调用的是子类中的同名成员
	s.fun();
	//如果子类中出现和父类同名的成员函数，子类的同名成员会隐藏掉父类所有同名成员函数
	//如果调用父类的同名函数，需要加上作用域
	s.Base::fun();
}

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

多继承语法

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

菱形继承

菱形继承概念：

• 两个派生类继承一个基类；
• 又有某个类同时继承两个派生类；
• 这种继承被称为菱形继承。
  

菱形继承中的问题：

• 存在二义性：当菱形继承，两个父类拥有相同数据，需要加以作用域区分；
• 浪费存储空间：菱形继承导致数据有两份，导致资源浪费；

解决方法：
虚继承用于解决多继承下的菱形继承问题；

• 底层实现原理与编译器相关，一般通过虚基类指针和虚基类表实现，每个虚继承的子类都有一个虚基类指针（占用一个指针的存储空间，4字节）和虚基类表（不占用类对象的存储空间），需要注意的是，虚基类依旧会在子类里面存在拷贝，只是仅仅最多存在一份而已，并不是不在子类里面。

#include<iostream>
using namespace std;

//动物类
class Animal
{
public:
	int m_Age;
};

//羊类
//利用虚继承，继承之前加上关键字virtual变为虚继承
//Animal类称为虚基类
class Sheep :virtual public Animal
{  };

//驼类
class Tuo :virtual public Animal
{  };

//羊驼类
class SheepTuo :public Sheep,public Tuo
{  };

void test1()
{
	SheepTuo st;
	st.Sheep::m_Age = 18;
	st.Tuo::m_Age = 28;

	cout << "羊驼的年龄为" << st.m_Age << endl;//数据只有一份
}

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

• 下面查看一下SheepTuo类的对象模型：
  实际上，vbptr指的是虚基类表指针，该指针指向了一个虚基类表，虚表中记录了虚基类与本类的偏移地址，通过偏移地址，这样就找到了虚基类成员，而虚继承也不用像普通多继承那样维持着虚基类的两份同样的拷贝，节省了存储空间。