【C++继承】

继承的定义和概念

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

定义格式

class Derive : public Base
Base是父类，也叫基类，Derive是子类，也叫派生类

继承关系和访问限定符

1.基类的私有成员在子类都是不可见。不可见是指基类的私有成员还是被继承到了派生类对象中，但是语法上限制派生类对象不管在类里面还是类外面都不能去访问它。
2.基类的私有无论什么继承都是不可见。基类的其他成员在子类的访问方式 ：Min(成员在基类的访问限定符，继承方式)，public > protected> private。
3.class的默认继承方式是private,struct的默认继承方式是public。
4.在实际运用中一般使用都是public继承，几乎很少使用protetced/private继承，我们接下来讨论的也是public继承。

基类和派生类的赋值转换

class Base
{
public:
};
class Derive : public Base
{
public:
};

int main()
{
	Base b;
	Derive d;
	b = d;
	Base* pb = new Derive;
	Base& bb = d;
	return 0;
}

派生类对象可以赋值给基类的对象/基类的指针/基类的引用。
基类对象不能赋值给派生类对象。

继承中的作用域

1. 在继承体系中基类和派生类都有独立的作用域。
2. 子类和父类中有同名成员，子类成员将屏蔽父类对同名成员的直接访问，这种情况叫隐藏，也叫重定义。（在子类成员函数中，可以使用 基类::基类成员 显示访问）
3. 需要注意的是如果是成员函数的隐藏，只需要函数名相同就构成隐藏。

派生类的默认成员函数

class Base
{
public:
	Base(int b)
		:_b(b)
	{
		cout << "Base(int b)" << endl;
	}
	~Base()
	{
		cout << "~Base()" << endl;
	}
	Base(const Base& b)
	{
		_b = b._b;
		cout << "Base(const Base& b)" << endl;
	}
	Base& operator=(const Base& b)
	{
		cout << "Base& operator=(const Base& b)" << endl;
		if (this != &b)
		{
			_b = b._b;
		}
		return *this;
	}
private:
	int _b;
};

class Derive : public Base
{
public:
	Derive(int b, int d)
		:Base(b)
		, _d(d)
	{
		cout << "Derive(int b, int d)" << endl;
	}
	~Derive()
	{
		cout << "~Derive()" << endl;
	}
	Derive(const Derive& d)
		:Base(d) 基类和派生类的赋值转换
		,_d(d._d)
	{
		cout << "Derive(const Derive& d)" << endl;
	}
	Derive& operator=(const Derive& d)
	{
		if (this != &d)
		{
		基类和派生类的成员函数，函数名相同，构成隐藏，
		所以要指定作用域调用基类的赋值运算符重载
			Base::operator=(d); 
			_d = d._d;
		}
		return *this;
	}
private:
	int _d;
};

1. 派生类对象初始化先调用基类构造再调派生类构造。先父后子
   派生类的构造函数必须调用基类的构造函数初始化基类的那一部分成员。如果基类没有默认的构造函数，则必须在派生类构造函数的初始化列表阶段显示调用。
2. 派生类的拷贝构造函数必须调用基类的拷贝构造完成基类的拷贝初始化。
3. 派生类的operator=必须要调用基类的operator=完成基类的复制。
4. 派生类对象析构清理先调用派生类析构再调基类的析构。先子后父
   同时，这里不需要我们手动调用基类的析构，为了保证先子后夫，父类的析构会在子类析构之后自动调用
   子类的析构和父类的析构构成隐藏，因为多态的原因，类的析构函数会被特殊处理成destructor()
5. 派生类的默认成员函数和以前类似，唯一不同的是多了父类的那一部分，父类的这部分调用父类对应的函数来完成

继承和友元

友元关系不能继承

静态成员

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

菱形继承

单继承：一个子类只有一个直接父类时称这个继承关系为单继承
多继承：一个子类有两个或以上直接父类时称这个继承关系为多继承

菱形继承
class A
{
public :
	int _a;
};
class B : public A
{
public :
	int _b;
};
class C : public A
{
public:
	int _c;
};
class D : public B, public C
{
public :
	int _d;
};

int main()
{
	D dd;
	dd.A::_a = 1;
	dd.B::_a = 2;
	dd._b = 3;
	dd._c = 4;
	dd._d = 5;

	return 0;
}

菱形继承：菱形继承是多继承的一种特殊情况。
菱形继承有数据冗余和二义性的问题。

class A
{
public :
	int _a;
};
class B : virtual public A
{
public :
	int _b;
};
class C :virtual public A
{
public:
	int _c;
};
class D : public B, public C
{
public :
	int _d;
};

int main()
{
	D dd;
	dd.A::_a = 1;
	dd.B::_a = 2;
	dd._b = 3;
	dd._c = 4;
	dd._d = 5;

	return 0;
}

虚拟继承可以解决菱形继承的二义性和数据冗余的问题。但会改变类的内存模型。
中间对象中不存储基类对象，而在另一块内存中单独存储，不过中间类中会存储一个指针，指针指向一块内存空间—虚基表，内存空间存储着到基类对象的偏移量，通过偏移量就可以访问中间类的公共部分。

继承和组合

public继承是一种is-a的关系。也就是说每个派生类对象都是一个基类对象。
组合是一种has-a的关系。假设B组合了A，每个B对象中都有一个A对象。
优先使用对象组合，而不是类继承 。