C++继承

先写一个类A作为父类（基类），再写一个类B作为它的子类（派生类）。

class（子类）:（继承方式）父类。

这样就可以使子类获得父类的代码。

好处是可以减少代码量。

#include<iostream>
using namespace std;
class BasePage
{
public:
	void heator()
	{
		cout<<"首页、公开课、登录、注册（公共头部）"<<endl;
	}
	void footer()
	{
		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<<"C++学科视频"<<endl;
}
};
void test01()
{
	cout<<"Java的页面"<<endl;
	Java ja;
	ja.heator();
	ja.footer();
	ja.content();
	ja.left();
	cout<<"-------------------------------"<<endl;
	cout<<"Python的页面"<<endl;
	Python py;
	py.heator();
	py.footer();
	py.content();
	py.left();
	cout<<"-------------------------------"<<endl;
	cout<<"C++的页面"<<endl;
	CPP cpp;
	cpp.heator();
	cpp.footer();
	cpp.content();
	cpp.left();
	cout<<"-------------------------------"<<endl;
}

int main()
{
	test01();
}
 

三种继承方式：

子类继承了父类所有的成员，无法访问的成员是被编译器屏蔽了。

#include<iostream>
using namespace std;
class Base
{
public:
	int m_A;
private:
	int m_B;
protected:
	int m_C;
};
class Son:public Base
{
public:
	int m_D;
};

void test01()
{
	cout<<"size of son = "<<sizeof(Son)<<endl;
}

int main()
{
	test01();
}
 

子类与父类构造函数，析构函数的顺序：

#include<iostream>
using namespace std;
class Base
{
public:
	Base()
	{
		cout<<"Base的构造函数"<<endl;
	}
	~Base()
	{
		cout<<"Base的析构函数"<<endl;
	}
protected:
	int m_B;
private:
	int m_C;
};
class Son:public Base
{
public:
	Son()
	{
		cout<<"Son的构造函数"<<endl;
	}
	~Son()
	{
		cout<<"Son的析构函数"<<endl;
	}
};
void test01()
{
	//Base b;
	Son s;
}

int main()
{
	test01();
}

如果子类与父类中有同名的变量或函数，那么父类中的所有同名变量或函数将被隐藏。如果想要调用父类中被隐藏的这些，需要加上作用域。

#include<iostream>
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();
}
int main()
{
	test01();
	test02();
}

出现静态变量的情况：

#include<iostream>
using namespace std;
class Base
{
public:
	static int m_A;
	static void func()
	{
		cout<<"Base-static void func()"<<endl;
	}
};
int Base::m_A=100;
class Son:public Base
{
public:
	static int m_A;
	static void func()
	{
		cout<<"Son-static void func()"<<endl;
	}
};
int Son::m_A=200;
void test01()
{ 
	Son s;
	cout<<"通过对象访问："<<endl;
	cout<<"Son 下 m_A = "<<s.m_A<<endl;
	cout<<"Base 下 m_A = "<<s.Base::m_A<<endl;
	cout<<"通过类名访问："<<endl;
	cout<<"Son 下 m_A = "<<Son::m_A<<endl;
	cout<<"Base 下 m_A = "<<Son::Base::m_A<<endl;
}
void test02()
{
	Son s;
	cout<<"通过对象访问："<<endl;
	s.func();
	s.Base::func();
	cout<<"通过类名访问："<<endl;
	Son::func();
	Son::Base::func();
}
int main()
{
	test01();
	test02();
}