C++ 继承

继承机制是面向对象程序设计使代码可以复用的最重要的手段，它允许程序员在保持原有类特性的基础上进行扩展，增加功能。这样产生新的类，称派生类。

继承关系&访问限定符

继承方式与成员访问权限测试代码

#include <iostream>
using namespace std;

class Person
{
public:
	int _age;
protected:
	int _weight;
private:
	int _hight; 
};

class Student: public Person
//class Student: protected Person
//class Student: private Person
{
public:
	void fun()
	{
		_age = 22;
		_weight = 65;
		//_hight = 174;
	}
};

void test()
{
	Student s;
	s.fun();
}

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

总结：

1. 基类的private成员在派生类中是不能被访问的，如果基类成员不想在类外直接被访问，但需要在派生类中能访问，就定义为protected。可以看出保护成员限定符是因继承才出现的。

2. public继承是一个接口继承，保持is-a原则，每个父类可用的成员对子类也可用，因为每个子类对象也都是一个父类对象。

3. protected/private继承是一个实现继承，基类的部分成员并非完全成为子类接口的一部分，是 has-a 的关系原则，所以非特殊情况下不会使用这两种继承关系，在绝大多数的场景下使用的都是公有继承。

4. 不管是哪种继承方式，在派生类内部都可以访问基类的公有成员和保护成员，基类的私有成员存在但是在子类中不可见（不能访问）。

5.类(class)的默认继承方式是private，结构体(struct)的默认继承方式是public，不过最好显示的写出继承方式。

6. 在实际运用中一般使用都是public继承，极少场景下才会使用protetced/private继承.

类对象模型（基类（在继承后）的类对象模型在前。（可查看内存））

#include <iostream>
using namespace std;

class A
{
public:
	int _a;
};

class B: public A
{
public:
	int _b;
};

int main()
{
	A a;
	a._a = 0;
	B b;
	b._a = 1;
	b._b = 2;
	return 0;
}

继承关系中构造函数&析构函数的调用顺序

#include <iostream>
using namespace std;

class A
{
public:
	A()
	{
		cout<<"A:A()"<<endl;
	}

	~A()
	{
		cout<<"A:~A()"<<endl;
	}
};

class B : public A
{
public:
	B()
	{
		cout<<"B:B()"<<endl;
	}

	~B()
	{
		cout<<"B:~B()"<<endl;
	}
};

int main()
{
	B b;
	return 0;
}

执行结果

通过调试，程序先调派生类的构造函数，然后跳至基类中，先执行基类的构造函数，再执行派生类的构造函数。析构时，先析派生类，然后跳至积累中，再析构基类。

说明：

1、基类没有缺省构造函数，派生类必须要在初始化列表中显式给出基类名和参数列表。（意思就是基类中有带参的构造函数，根据上面继承中调用构造函数的顺序，所以要在派生类构造函数中显示的初始化基类成员变量）

#include <iostream>
using namespace std;

class A
{
public:
	A(int x)
		:_a(x)
	{}

	int _a;
};

class B : public A
{
public:
	B(int x, int y)
		:A(x)
		,_b(y)
	{}

	int _b;
};

int main()
{
	B b(1, 2);
	return 0;
}

2、基类没有定义构造函数，则派生类也可以不用定义，全部使用缺省构造函数。（2、3比较好理解，没有给出测试代码）

3、基类定义了带有形参表构造函数，派生类就一定定义构造函数。

继承与转换---赋值兼容规则---继承方式：public

#include <iostream>
using namespace std;

class Person
{
public:
	int _age;
};

class Student: public Person
{
public:
	Student()
		:_num(0)
	{}

	int _num;
};

void test()
{
	Person p;
	Student s;

	//子类对象可以赋值给父类对象(切割/切片)
	p = s;
	//父类对象不能赋值给子类对象
	//s = p;//错误

	//父类的指针/引用可以指向子类对象
	Person* p1 = &s;
	Person& r1 = s;
	//子类的指针/引用不能指向父类对象（可以通过强制类型转换完成）
	Student* p2 = (Student*)&p;
	Student& r2 = (Student&)p;

	//下面两行代码运行时都会崩溃（语法正确，调试时无错误警告），因为权限只能缩小，不能放大，会出现越界访问
	//p2->_num = 10;
	//r2._num = 20;
}

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

继承体系中的作用域

1. 在继承体系中基类和派生类是两个不同作用域。

2. 子类和父类中有同名成员，子类成员将屏蔽父类对成员的直接访问。（在子类成员函数中，可以使用 基类::基类成员 访问）

3. 注意在实际中在继承体系里面最好不要定义同名的成员。

#include <iostream>
using namespace std;

class A
{
public:
	void Print()
	{
		cout<<"A:Print()"<<endl;
	}

	int _a;
};

class B: public A
{
public:
	void Print(int n)
	{
		cout<<"B:Print()"<<endl;
	}

	int _a;
	int _b;
};

int main()
{
	B b;
	cout<<sizeof(b)<<endl;
	b.Print(0);//调用派生类的Print()。基类、派生类中的同名隐藏，函数同名隐藏与其参数类型无关
	b.A::Print();//调用基类的Print()
	b.A::_a = 1;
	b.B::_a = 2;
	b._b = 3;
	return 0;
}

友元与继承

友元函数不是成员函数，所以友元关系不能继承，也就是说基类友元函数不能访问子类中的成员。但是派生类的友元函数有且只能访问基类的公有成员

#include <iostream>
using namespace std;

class A
{
public:
	int _b1;
protected:
	int _b2;
private:
	int _b3;
};

class B : public A
{
	friend void Display(A& a, B& b);
};

void Display(A& a, B& b)
{
	cout<<a._b1<<endl;
	//cout<<a._b2<<endl;
	//cout<<a._b3<<endl;
}

int main()
{
	A a;
	B b;
	Display(a, b);
	return 0;
}

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

总结：

子类不能从父类继承的有：(因其功能决定)
1.构造函数 2.拷贝构造函数3.析构函数 4.友元函数(不是类的成员函数)