继承 一.继承的基本语法

• 继承的好处：减少重复代码
• 语法：class  子类 ：继承方式  父类

class java : public backpage

• 子类   也称为   派生类
• 父类   也称为   基类

二.继承的方式

1. 公共继承
2. 保护继承
3. 私有继承

 

#include
#include
using namespace std;

class base
{
public:
	int m_a;
protected:
	int m_b;
private:
	int m_c;
};

class son1 :public base
{
public:
	void fun()
	{
		m_a = 10;//父类的公共权限   子类还是公共权限
		m_b = 10;//父类的保护权限   子类还是保护权限
      //m_c = 10;//父类的私有权限   子类还是访问不到
	}
};

class son2 :protected base
{

protected:
	void fun()
	{
		m_a = 10;//父类的公共权限   子类是保护权限
		m_b = 10;//父类的保护权限   子类还是保护权限
	  //m_c = 10;//父类的私有权限   子类还是访问不到
	}
};

class son3 :private base
{

private:
	void fun()
	{
		m_a = 10;//父类的公共权限   子类是私有权限
		m_b = 10;//父类的保护权限   子类还是私有权限
	  //m_c = 10;//父类的私有权限   子类还是访问不到
	}
};
void test01()
{
	son1 s1;
	s1.m_a = 100;
	//s1.m_b;  son1 中  m_b是保护权限，类外访问不到
}
void test02()
{
	son2 s2;
	//s2.m_a = 10;  父类中是公共权限   到子类中变成了保护权限，类外访问不到了
	//s2.m_b = 10;  父类中是保护权限   到子类中还是保护权限，类外访问不到了
}

void test03()
{
	son3 s3;
	//s3.m_a = 10;  父类中是公共权限   到子类中变成了保护权限，类外访问不到了

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

三.继承中的对象模型

私有成员只是被隐藏了，但是还是会继承下去，所以子类的对象包过它自己本身的外，还包含父类中继承的，非隐藏的加隐藏的。 

四.继承中的构造函数和析构函数

子继承父类后，当创建类对象的时候（参照析构函数和构造函数）

• 构造函数：父类构造函数先有  
• 析构函数:   子类析构函数先出

#include
#include
using namespace std;

class base
{
public:
	base()
	{
		cout << "父类的构造函数" << endl;
	}
	~base()
	{
		cout << "父类的构造函数" << endl;
	}
	int m_a=0;
protected:
	int m_b;
private:
	int m_c;
};

class son1 :public base
{
public:
	son1()
	{
		cout << "子类的构造函数：" << endl;
	}
	~son1()
	{
		cout << "子类的析构函数：" << endl;
	}
	int m_d;
};

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

五.继承同名成员处理方式

• 访问子类中同名函数  直接访问即可
• 访问父类同名函数  需要加作用域

#include
#include
using namespace std;

class base
{
public:
	void fun()
	{
		cout << "访问的是父类！" << endl;
	}
	int m_a=10;
protected:
	int m_b;
private:
	int m_c;
};

class son1 :public base
{
public:
	void fun()
	{
		cout << "访问的是子类!" << endl;
	}
	int m_a=20;
};

void test01()
{
	son1 s1;
	cout << "子类中的 s1.m_a=" << s1.m_a << endl;
	//如果通过子类对象 访问到父类中同名成员，需要加作用域
	cout << "父类中的 s1.m_a=" << s1.base::m_a << endl;
	s1.fun();
	//如果通过子类对象 访问到父类中同名函数，需要加作用域
	s1.base::fun();
}
int main()
{
	test01();
	system("pause");
	return 0;
}

六.继承同名静态成员处理方式

静态成员和非静态成员出现同名，处理方式一样

• 访问子类中同名函数  直接访问即可
• 访问父类同名函数  需要加作用域

静态成员有两种访问方式

• 通过对象来访问数据
• 通过类名来访问数据

 //第一个“：：”代表通过类名方式访问，第二个“：：”代表访问父类作用域
    cout << "父类下的m_a=" << son1::base::m_a << endl;

#include
#include
using namespace std;

class base
{
public:
	static void fun()
	{
		cout << "父类的调用" << endl;
	}
	static int m_a;
};
int base::m_a = 10;//类内申明  类外初始化

class son1 :public base
{
public:
	static void fun()
	{
		cout << "子类的调用" << endl;
	}
	static int m_a;
};
int son1::m_a = 20;

void test01()
{
	//通过对象来访问数据
	cout << "通过对象访问：" << endl;
	son1 s1;
	cout <<"子类的s1.m_a=" << s1.m_a << endl;
	cout << "父类的s1.m_a=" << s1.base::m_a << endl;
	//通过类名来访问数据
	cout << "通过类名访问：" << endl;
	cout << "子类下的m_a=" << son1::m_a << endl;
    //第一个“：：”代表通过类名方式访问，第二个“：：”代表访问父类作用域
	cout << "父类下的m_a=" << son1::base::m_a << endl;
}
void test02()
{
	//通过对象来访问数据
	cout << "通过对象访问：" << endl;
	son1 s;
	s.fun();
	s.base::fun();
	//通过类名来访问数据
	cout << "通过类名访问：" << endl;
	son1::fun();
	son1::base::fun();
}
int main()
{
	//test01();
	test02();
	system("pause");
	return 0;
}