c++学习——继承

继承

普通的输出

#define _CRT_SECURE_NO_WARNINGS
#include 
using namespace std;

//普通实现页面
//java页面
class Java
{
public:
	void header()
	{
		cout << "首页、公开课、登录、注册...(公共头部)" << endl;
	}
	void footet()
	{
		cout << "帮助中心、交流合作、站内地图...(公共底部)" << endl;
	}
	void left()
	{
		cout << "Java,Python,c++...(公共分类列表)" << endl;
	}
	void content()
	{
		cout << "Java学科的视频" << endl;
	}
};

class Python
{
public:
	void header()
	{
		cout << "首页、公开课、登录、注册...(公共头部)" << endl;
	}
	void footet()
	{
		cout << "帮助中心、交流合作、站内地图...(公共底部)" << endl;
	}
	void left()
	{
		cout << "Java,Python,c++...(公共分类列表)" << endl;
	}
	void content()
	{
		cout << "Python学科的视频" << endl;
	}
};

class Cpp
{
public:
	void header()
	{
		cout << "首页、公开课、登录、注册...(公共头部)" << endl;
	}
	void footet()
	{
		cout << "帮助中心、交流合作、站内地图...(公共底部)" << endl;
	}
	void left()
	{
		cout << "Java,Python,c++...(公共分类列表)" << endl;
	}
	void content()
	{
		cout << "Python学科的视频" << endl;
	}
};

void test01()
{
	cout << "Java的下载视频页面如下：" << endl;
	Java ja;
	ja.header();
	ja.footet();
	ja.left();
	ja.content();
	
	cout << "--------------------" << endl;
	Python py;
	py.header();
	py.footet();
	py.left();
	py.content();

	cout << "--------------------" << endl;
	Cpp cpp;
	cpp.header();
	cpp.footet();
	cpp.left();
	cpp.content();

}

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

继承的案例

继承的好处
减少重复的代码
**继承的语法：class 子类 : 继承方式 父类 **
子类也称为派生类 父类也称为派生类

#define _CRT_SECURE_NO_WARNINGS
#include 
using namespace std;
//继承实现页面
//公共页面类
class BasePage
{
public:
	void header()
	{
		cout << "首页、公开课、登录、注册...(公共头部)" << endl;
	}
	void footet()
	{
		cout << "帮助中心、交流合作、站内地图...(公共底部)" << endl;
	}
	void left()
	{
		cout << "Java,Python,c++...(公共分类列表)" << endl;
	}
};

class Java : public BasePage
{
public:
	void content()
	{
		cout << "Java学科的视频" << endl;
	}
};

class Python : public BasePage
{
public:
	void content()
	{
		cout << "Python学科的视频" << endl;
	}
};

class Cpp : public BasePage
{
public:
	void content()
	{
		cout << "Cpp学科的视频" << endl;
	}
};

void test01()
{
	cout << "Java的下载视频页面如下：" << endl;
	Java ja;
	ja.header();
	ja.footet();
	ja.left();
	ja.content();
	
	cout << "--------------------" << endl;
	Python py;
	py.header();
	py.footet();
	py.left();
	py.content();

	cout << "--------------------" << endl;
	Cpp cpp;
	cpp.header();
	cpp.footet();
	cpp.left();
	cpp.content();

}

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

继承的三种方式方式：

公有继承
私有继承
保护继承

#define _CRT_SECURE_NO_WARNINGS
#include 
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 = 10; // 父类中的公共权限成员到子类中依然是公共权限
		m_B = 10; // 父类中的保护权限成员到子类中依然是保护权限
		//m_C = 10; err // 父类中的私有权限成员到子类中访问不到
	}
};

void test01()
{
	Son1 s1;
	//公共权限类内可以访问  类外也可以访问
	s1.m_A = 100;
	//到了子类中 是保护权限  
	//类内可以访问  类外不可以访问
	//s1.m_B = 100;  err
}

class Base2
{
public:
	int m_A;
protected:
	int m_B;
private:
	int m_C;
};

//保护继承
class Son2 :protected Base2
{
public:
	void func()
	{
		m_A = 10; // 父类中的公共权限成员到子类中是保护权限
		m_B = 10; // 父类中的保护权限成员到子类中依然是保护权限
		//m_C = 10; err // 父类中的私有权限成员到子类中访问不到
	}
};

void test02()
{
	Son2 s1;
	//s1.m_A = 1000;//err
	//s1.m_B = 1000;//err
}


class Base3
{
public:
	int m_A;
protected:
	int m_B;
private:
	int m_C;
};


class Son3 :private Base3
{
public:
	void func()
	{
		m_A = 10; // 父类中的公共权限成员到子类中是私有权限
		m_B = 10; // 父类中的保护权限成员到子类中是私有权限
		//m_C = 10; err // 父类中的私有权限成员到子类中访问不到
	}
};

void test03()
{
	Son2 s1;
	//s1.m_A = 1000;//err
	//s1.m_B = 1000;//err
}

class GrandSon3 :public Son3
{
public:
	void func()
	{
		//到了Son3中，即使是儿子也是访问不到的
		//m_A = 1000;//err
		//m_B = 1000;//err
	}
};

int main()
{
	//test01();
	//test02();
	test03();
	system("pause");
	return EXIT_SUCCESS;
}

继承中的对象类型

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

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

可以利用这个工具查看对象模型

利用开发人员命令提示工具查看对象模型
跳转文件路径cd 具体路径下
查看命名
cl /dl reportSingleclassLayout类名 文件名
1、2、
就能看到这个继承的对象模型

继承中的构造和析构顺序

#define _CRT_SECURE_NO_WARNINGS
#include 
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()
{
	//Base b;
	//cout << "------------------" << endl;

	//继承中的构造和析构的顺序如下:
	//先构造父类，再构造子类，析构的顺序与构造的顺序相反
	Son s;
}

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

继承中同名成员的处理

#define _CRT_SECURE_NO_WARNINGS
#include 
using namespace std;

//继承中同名成员的处理
class Base
{
public:
	Base()
	{
		m_A = 100;
	}

	void func()
	{
		cout << "Base-func()的调用" << endl;
	}

	void func(int a)
	{
		cout << "Base-func(int a)的调用" << endl;
	}
	int m_A;
};

class Son :public Base
{
public:
	Son()
	{
		m_A = 200;
	}

	void func()
	{
		cout << "Son-func调用" << endl;
	}
	int m_A;
};

//同名的成员属性的处理方式
void test01()
{
	Son s;
	cout << "Son 下 m_A=" << s.m_A << endl;
	//如果通过子类对象 访问到父类中的同名成员，需要加作用域
	cout << "Base 下 m_A=" << s.Base::m_A << endl;
}

//同名成员函数处理方式
void test02()
{
	Son s;
	
	s.func();//直接调用 调用的是子类中的同名成员

	//如何调用到父类中同名成员函数
	s.Base::func();

	//如果子类中出现和父类同名的成员函数，子类的同名成员会隐藏掉父类中所有同名成员函数
	//s.func(100);err

	//访问子类的同名成员隐藏掉父类中所有同名成员函数，需要加作用域
	s.Base::func(100);//调用函数重载
}

int main()
{
	//test01();
	test02();
	system("pause");
	return EXIT_SUCCESS;
}

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

同名静态成员处理

#define _CRT_SECURE_NO_WARNINGS
#include 
using namespace std;

//继承中的同名静态成员处理方式

class Base
{
public:
	static int m_A;
	
	static void func()
	{
		cout << "Base - static void()的调用" << endl;
	}

	static void func(int a)
	{
		cout << "Base - static void(int)的调用" << endl;
	}
};

int Base::m_A = 100;

class Son :public Base
{
public:
	static int m_A;
	static void func()
	{
		cout << "Son - static void()的调用" << endl;
	}
};

int Son::m_A = 200;

//同名静态成员属性
void test01()
{
	//1、通过对象来访问数据
	cout << "通过对象访问:" << endl;
	Son s;
	cout << "Son 下 m_A=" << s.m_A << endl;
	cout << "Base 下 m_A=" << s.Base::m_A << endl;

	//2、通过类名来访问数据
	cout << "通过类名来访问:" << endl;
	cout << "Son 下 m_A=" << Son::m_A << endl;
	//第一个::代表通过类名方式访问     
	//第二个::代表访问父类作用域下
	cout << "Base 下 m_A=" << Son::Base::m_A << endl;

}

//同名静态成员函数
void test02()
{
	//1、通过对象访问
	cout << "通过对象访问:" << endl;
	Son s;
	s.func();
	s.Base::func();

	//2、通过类名访问
	cout << "通过类名来访问:" << endl;
	Son::func();
	Son::Base::func();

	//子类出现了和父类同名的静态成员函数，也会隐藏父类中所有同名成员函数
	//如果想访问父类中被隐藏的同名函数，要加作用域
	Son::Base::func(100);
}

int main()
{
	//test01();
	test02();
	system("pause");
	return EXIT_SUCCESS;
}

多继承语法

#define _CRT_SECURE_NO_WARNINGS
#include 
using namespace std;

//多继承语法
class Base1
{
public:
	Base1()
	{
		m_A = 100;
	}

	int m_A;
};

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

	int m_A;
};

//子类 需要继承Base1和Base2
//语法：class 子类:继承方式 父类1，继承方式 父类2 ...
class Son :public Base1, public Base2
{
public:
	Son()
	{
		m_C = 300;
		m_D = 400;
	}
	int m_C;
	int m_D;
};

void test01()
{
	Son s;
	cout << "sizeof Son " << sizeof(s) << endl;
	//当父类中出现了同名成员，需要加作用域区分
	//不然有二义性
	cout << "m_A" << s.Base1::m_A << endl;
	cout << "m_A" << s.Base2::m_A << endl;

}

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

菱形继承

菱形继承的问题：
会导致数据有两份，导致资源的浪费

#define _CRT_SECURE_NO_WARNINGS
#include 
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 test01()
{
	SheepTuo st;
	st.Sheep::m_Age = 18;
	st.Tuo::m_Age = 28;//覆盖掉了

	//当菱形继承的时候，两个父类拥有相同的数据，需要加以作用域去区分
	cout << "st.Sheep::m_Age=" << st.Sheep::m_Age << endl;
	cout << "st.Tuo::m_Age=" << st.Tuo::m_Age << endl;
	//这份数据我们知道只有有一份就可以，菱形继承导致数据有两份，资源浪费
	cout << "st.m_Age=" << st.m_Age << endl;
}

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

虚继承的底层逻辑

vbptr是虚基类指针
32位系统指针占了4个字节