在保护继承中基类的共有成员_类与对象-继承

一、继承基本语法

继承是面向对象三大特性之一，其好处是可以减少重复的代码：class A : public B; 中A 类称为子类或派生类，B 类称为父类或基类。

派生类中的成员，包含两大部分：一类是从基类继承过来的，一类是自己增加的成员。从基类继承过过来的表现其共性，而新增的成员体现了其个性。

以公有继承为例：

class Base
{
public:
	void header()
	{
		cout << "首页" << endl;
	}
	void footer()
	{
		cout << "帮助中心" << endl;
	}
	void left()
	{
		cout << "分类列表" << endl;
	}
};

//java页面
class Java :public Base
//class 子类（派生类） : 继承方式 父类（基类）
{
public:
	void content()
	{
		cout << "Java学习" << endl;
	}
};

//CPP页面
class CPP :public Base
{
public:
	void content()
	{
		cout << "CPP学习" << endl;
	}
};

void test()
{
	Java j;
	j.header();
	j.footer();
	j.left();
	j.content();

	cout << endl;

	CPP c;
	c.header();
	c.footer();
	c.left();
	c.content();
}

int main()
{
	test();
	return 0;
}
/*
输出：
首页
帮助中心
分类列表
Java学习

首页
帮助中心
分类列表
CPP学习
*/

二、继承方式

继承方式一共有三种：

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

区别如下：

示例：

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;//保护成员父类到子类后依然是保护权限
	}
};

class Son2 :protected Base1
{
public:
	void func()
	{
		m_A = 10;//公共成员父类到子类后变为保护权限
		m_B = 10;//保护成员父类到子类后依然是保护权限
	}
};

class Son3 :private Base1
{
public:
	void func()
	{
		m_A = 10;//公共成员父类到子类后变为私有权限
		m_B = 10;//保护成员父类到子类后变为私有权限
	}
};

三、继承中的对象模型

父类中私有成员也是被子类继承下去了，只是由编译器给隐藏后访问不到。

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

class Son :public Base
{
public:
	int m_D;
};

void test()
{
	cout << "子类的大小为" << sizeof(Son) << endl;
	//父类私有成员被子类继承，不被访问
}

int main()
{
	test();
	return 0;
}
/*
输出：
子类的大小为16
*/

利用工具查看：

四、继承中的构造和析构顺序

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

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();
	return 0;
}

五、同名成员处理方式

同名成员处理方式：

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

class Base
{
public:
	Base()
	{
		m_A = 100;
	}
	void func()
	{
		cout << "父类func调用" << endl;
	}
	void func(int a)//重载
	{
		cout << a << endl;
	}
	int m_A;
};

class Son :public Base
{
public:
	Son()
	{
		m_A = 200;
	}	
	void func()
	{
		cout << "子类func调用" << endl;
	}
	int m_A;
};

void test1()
{
	Son s;
	cout << s.m_A << endl;//同名下访问子类中的成员
	cout << s.Base::m_A << endl;//同名下访问父类中成员需要加作用域
	s.func();//同名下访问子类中的函数成员
	s.Base::func();//同名下访问父类中函数成员需要加作用域
	s.Base::func(100);
}

int main()
{
	test1();
	return 0;
}
/*
输出：
200
100
子类func调用
父类func调用
100
*/

六、同名静态成员处理

同名静态成员处理方式和非静态处理方式一样，只不过有两种访问的方式，通过对象和通过类名。静态成员需要类外初始化。

class Base
{
public:
	static string m_A;
};

string Base::m_A = "父类成员";

class Son :public Base
{
public:
	static string m_A;
};
string Son::m_A = "子类成员";

void test()
{
	Son s;
	//通过对象访问
	cout << s.m_A << endl;//子类静态成员变量
	cout << s.Base::m_A << endl;//父类静态成员变量
	//通过类名访问
	cout << Son::m_A << endl;
	cout << Base::m_A << endl;
	cout << Son::Base::m_A << endl;
}

int main()
{
	test();
	return 0;
}
/*
输出：
子类成员
父类成员
子类成员
父类成员
父类成员
*/

七、多继承语法

多继承可能会引发父类中有同名成员出现，需要加作用域区分：

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

class Base2
{
public:
	Base2()
	{
		m_B = 200;
	}
	int m_B;
};

class Son :public Base1,public Base2
{
public:
	Son()
	{
		m_C = 300;
		m_D = 400;
	}
	int m_C, m_D;
};

void test()
{
	Son s;
	cout << sizeof(s) << endl;
	cout << s.Base1::m_A << endl;
	cout << s.Base2::m_B << endl;
}

int main()
{
	test();
	return 0;
}

八、菱形继承

菱形继承概念：

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

特点：

• 菱形继承带来的主要问题是子类继承两份相同的数据，导致资源浪费以及毫无意义
• 利用虚继承可以解决菱形继承问题

class Person//虚基类
{
public:
	int m_age;
};

//在关键词前加virtual，转为虚继承
class p1: virtual public Person {};
class p2: virtual public Person {};
class p3: public p1,public p2 {};

void test()
{
	p3 p;
	p.p1::m_age = 18;
	p.p2::m_age = 20;
	cout << p.p1::m_age << endl;//输出最后一次修改的值(vbptr虚基类指针)
	cout << p.p2::m_age << endl;
}
int main()
{
	test();
	return 0;
 }