C++继承

继承是面向对象设计中的一个概念，与多态（点此进入）、封装并称为面向对象设计的三大特性。

继承是使代码复用的一种手段，是类设计层次的复用，可以使子类（派生类）具有父类（基类）的属性和方法或者重新定义、追加属性和方法。

下面举一个最基本的例子说明继承：

class A
{
public:
	void Func1() {};
	void Func2() {};
};

class B : public A
{
public:
	void Func3() {};
	void Func4() {};
};

int main()
{
	B b;
	b.Func1();
	b.Func2();
	b.Func3();
	b.Func4();
	return 0;
}

B类创建的对象b不仅可以调用自己类中的函数Func3、Func4，而且可以调用A类中的函数Func1、Func2。可以证明B类从A类中继承了A类所具有属性。

 

继承与组合

那么什么时候才继承呢？和继承相对的一种方法是组合。

继承：若逻辑上B是A的一种，则允许B继承A的功能和属性。

           男人和女人都是人，所以男人和女人都继承于人。

组合：若逻辑上B是A的一部分，则不允许B继承A，只能采用组合。

          人的身体部位如头、臂、脚是人体的一部分，只能由头和其他部位组合成人。

下面是组合的例子：

class Eye
{
public:
	void Look()
	{
		cout << "i am eye" << endl;
	}
};

class Nose
{
public:
	void Smell()
	{
		cout << "i am nose" << endl;
	}
};

class Mouth
{
public:
	void Speak()
	{
		cout << "i am mouth" << endl;
	}
};

class Ear
{
public:
	void Listen()
	{
		cout << "i am ear" << endl;
	}
};

class Head
{
public:
	void Look() { _eye.Look(); }
	void Smell() { _nose.Smell(); }
	void Speak() { _mouth.Speak(); }
	void Listen() { _ear.Listen(); }
private:
	Eye _eye;
	Nose _nose;
	Mouth _mouth;
	Ear _ear;
};

组合优先级高于继承。若能组合就不用继承。

继承方式中，基类内部细节对子类可见。继承在一定程度上破坏了基类的封装，基类的改变对派生类有很大影响。基类和派生类的依赖性很强，耦合度高。

组合要求被组合的对象具有良好定义的接口，因此对象的内部细节不可见。所以组合类之间没有很强的依赖关系，耦合度低。

 

继承关系

继承关系有三种：public（共有）、private（私有）、protected（受保护类成员

类成员/继承方式	public继承	protected继承	private继承
基类的public成员	派生类的public成员	派生类的protected成员	派生类的privagte成员
基类的protected成员	派生类的protected成员	派生类的protected成员	派生类的private成员
基类的private成员	在派生类中不可见	在派生类中不可见	在派生类中不可见

注意：以上的的不可见指基类的私有成员还是被继承到了派生类中，但是语法上限制不管在类里面还是类外面都不能访问它。

实际应用中一般使用的都为public继承。因为protected/private继承下来的成员都只能在派生类的类中使用，实际扩展维护性不强。

 

继承中的作用域

1、基类和派生类都有自己独立的作用域。

2、当基类和派生类有同名成员时，派生类会屏蔽基类的成员的直接访问，这种情况称为隐藏（重定义）。（要想直接访问基类的成员可以用  基类：：基类成员 显示访问）

3、只要成员函数名相同就会构成隐藏。

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

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

int main()
{
	B b;
	b.Func();//此时调用的时B类的Func
        b.A::Func();//此时调用的是A类的Func
	return 0;
}

 

派生类的默认成员函数

1. 派生类的构造函数必须调用基类的构造函数初始化基类的成员。（如果基类没有默认的构造函数，则必须在派生类构造函数的初始化列表阶段显示调用）

2. 派生类的拷贝构造函数必须调用基类的拷贝构造完成基类的拷贝初始化。

3. 派生类的operator=必须要调用基类的operator=完成基类的复制。

4. 派生类的析构函数会在被调用完成后自动调用基类的析构函数清理基类成员。因为这样才能保证派生类对象先清理派生类成员再清理基类成员的顺序。

5. 派生类对象初始化先调用基类构造再调派生类构造。

6. 派生类对象析构清理先调用派生类析构再调基类的析构。

class A
{
public:
	A(const int a = 0):_a(a)
	{
		cout << "A()" << endl;
	}
	A(const A& a): _a(a._a)
	{
		cout << "A(const A& a)" << endl;
	}
	A& operator=(const A& a)
	{
		cout << "A& operator=(const A& a)" << endl;
		if (this !=  &a)
		{
			_a = a._a;
		}
		return *this;
	}
	~A()
	{
		cout << "~A()" << endl;
	}
protected:
	int _a;
};

class B : public A
{
public:
	B(const int a, int b) 
		: A(a)
		,_b(b)
	{
		cout << "B()" << endl;
	}
	B(const B& b) 
		: A(b)
		,_b(b._b)
	{
		cout << "B(const B& b)" << endl;
	}
	B& operator=(const B& b)
	{
		cout << "B& operator=(const B& b)" << endl;
		if (this != &b)
		{
			A::operator=(b);
			_b = b._b;
		}
		return *this;
	}
	~B()
	{
		cout << "~B()" << endl;
	}
protected:
	int _b;
};


int main()
{
	B B1(0,0);
	B B2(B1);
	B B3(0,0);
	B1 = B3;
	return 0;
}

结果

 

可见：

B B1(0,0)定义了一个B类对象。先调用了A类构造函数，在调用了B类的构造函数。

B B2（B1）先调用了A类拷贝构造函数，在调用了B类拷贝构造函数。

B1 = B3先调用了A类operator=函数，再调用了B类operator=函数。

对象B1、B2、B3析构时皆先调用B类析构函数，再调用A类析构函数。

继承中的多继承及菱形继承（点此进入）也是不可忽视的！