[C++] :继承

1.继承权限问题

先来看这样一个demo

#include<iostream>

class Person {
public:
	Person()
		:_a(1), _b(2), _c(3)
	{
		std::cout << _c << std::endl;
	}
	int _a;
protected:
	int _b;
private:
	int _c;
};
class man : protected Person {
public:
	man()
		:_d(1)
	{
		std::cout << _a << std::endl;
		std::cout << _b << std::endl;
		std::cout << _d << std::endl;
	}

private:
	int _d;
};
int main()
{
	man m;
	return 0;
}

我们以protected方式继承父类，并且访问所有成员，便可发现父类的private成员_c无法访问，而public成员和protected成员均可访问，所以我么你可以得出以下结论。

• public继承：父类的public成员和protected成员，分别是子类的public成员和protected成员
• protected继承：父类的public成员和protected成员，均是子类的protected成员
• private继承：父类所有成员都是子类的private成员

2.基类和派生类对象赋值转换

• 派生类对象 可以赋值给 基类的对象 / 基类的指针 / 基类的引用。（切片）
• 基类对象不能赋值给派生类对象
• 基类的指针可以通过强制类型转换赋值给派生类的指针。

3.继承中的作用域

• 子类和父类中有同名成员，子类成员将屏蔽父类对同名成员的直接访问，这种情况叫隐藏，也叫重定 义。（在子类成员函数中，可以使用 基类::基类成员 显示访问）

• 需要注意的是如果是成员函数的隐藏，只需要函数名相同就构成隐藏。在实际中在继承体系里面最好不要定义同名的成员

来看这样一个demo

//注意这里fun（）函数就构成隐藏而不是重载，因为不在同一作用域
//成员函数名相同即可构成隐藏
#include<iostream>

class Person {
public:
	void fun() {
		std::cout << "fun()---" << std::endl;
	}
};

class Stu : public Person {
public:
	void fun() {
		Person::fun();
		std::cout << "fun2()---" << std::endl;
	}
};

int main()
{
	Stu s;
	s.fun();
	return 0;
}

4.派生类的默认成员函数

来看这样一个demo：

#include<iostream>
#include<string>
class Person {
public:
	Person(const char* name = "Pony")
		:_name(name)
	{
		std::cout << "Person()" << std::endl;
	}
	Person(const Person& p)
		:_name(p._name)
	{
		std::cout << "Person(const Person& p)" << std::endl;
	}
	Person& operator=(const Person& p)
	{
		std::cout << "Person operator=(const Person& p)" << std::endl;
		if (this != &p)
			_name = p._name;
		return *this;
	}
	~Person() { std::cout << "~Person()" << std::endl; }
private:
	std::string _name;
};

class Student : public Person {
public:
	Student(const char* name, int num)
		:Person(name), _num(num)
	{
		std::cout << "Student()" << std::endl;
	}
	Student(const Student& s)
		:Person(s), _num(s._num)
	{
		std::cout << "Student(const Student &s)" << std::endl;
	}
	Student& operator=(const Student& s)
	{
		
		if (this != &s)
		{
			Person::operator=(s);
			_num = s._num;
		}
		std::cout << "Student& operator=(const Student& s)" << std::endl;
		return *this;
	}
	~Student() { std::cout << "~Student()" << std::endl; }
private:
	int _num;
};

int main()
{
	Student s1("jack", 18);
	Student s2(s1);
	Student s3("kiki", 20);
	s3 = s1;
	system("pause");
	return 0;
}

分析上图的运行结果我们不难发现：

1. 派生类的构造函数必须调用基类的构造函数初始化基类的那一部分成员。如果基类没有默认的构造函数，则必须在派生类构造函数的初始化列表阶段显示调用。
2. 派生类的拷贝构造函数必须调用基类的拷贝构造完成基类的拷贝初始化。
3. 派生类的operator=必须要调用基类的operator=完成基类的复制。
4. 派生类对象初始化先调用基类构造再调派生类构造。
   再来看这样一个demo：

#include<iostream>
class A {
public:
	~A() {
		std::cout << "~A()" << std::endl;
	}
};
class B : public A{
public:
	B(int b = 10)
		:A(), _b(b){}
	~B() {
		std::cout << "~B()" << std::endl;
	}
	int _b;
};
int main()
{
	B b;
	B b2;
	b = b2;
	return 0;
}

分析上图运行结果我们可以得到以下结论：
2. 派生类对象析构清理先调用派生类析构再调基类的析构。
3. 派生类的析构函数会在被调用完成后自动调用基类的析构函数清理基类成员。因为这样才能保证派生类 对象先清理派生类成员再清理基类成员的顺序。

5.继承与静态成员

基类定义了static静态成员，则整个继承体系里面只有一个这样的成员。无论派生出多少个子类，都只有一 个static成员实例 。

来看一下demo：

#include<string>
#include<iostream>
class Person {
public:
	Person() { ++_count; }
protected:
	std::string _name;
public:
	static int _count;
};

int Person::_count = 0;
class Student : public Person {
protected:
	int _num;
};

class Graduate : public Student {
protected:
	std::string _Course;
};

void Test(){
	Student s1;
	Student s2;
	Student s3;
	Graduate s4;
	std::cout << "人数：" << Person::_count << std::endl;
	Student::_count = 0;
	std::cout << "人数：" << Person::_count << std::endl;
} 

int main()
{
	Test();
	return 0;                                            
}
//运行结果：人数： 4      人数： 0

6.继承与友元

友元关系不能继承，也就是说基类友元不能访问子类私有和保护成员

7.菱形继承与虚拟菱形继承

c++支持多继承，而菱形继承是多继承的一种特殊情况
例如类B，C继承了类A，而类D继承了类B和类C
显而易见的是此时类D拥有两份类A的成员，这是就出现了数据冗余及二义性，为了解决这个问题
便有了虚拟继承。

//todo 实现原理