C++继承

继承的概念及定义
 

继承的概念
 

继承机制是面向对象程序设计使代码可以复用的最重要的手段，它允许程序员在保持原有类特性的基础上进行扩展，增加功能，这样产生新的类，称派生类。继承呈现了面向对象程序设计的层次结构，体现了由简单到复杂的认知过程。以前我们接触的复用都是函数复用，继承是类设计层次的复用
 

如设计学生类和老师类，其实这两个类都存在许多相同之处（如姓名，年龄等），也有不同处（如学生类有学号，老师类有工号等）那么把这些相同之处提取出来，设计成一个类，再由学生类和老师类去继承它，就能实现代码复用

class Person//父类（基类）
{
public:
	void Print()
	{
		cout << "name: " << _name << endl;
		cout << "age: " << _age << endl;
	}
protected:
	string _name = "John";
	int _age = 18;
};

class Student:public Person//子类（派生类）
{
protected:
	int _stuid;//学号
};

class Teacher :public Person//子类（派生类）
{
protected:
	int _jobid;//工号
};

int main()
{
	Student s;
	Teacher t;
	s.Print();//可以复用父类的成员函数
	t.Print();
	return 0;
}

继承定义
 

定义格式

继承方式和访问限定符
 

 1 基类private成员在派生类中无论以什么方式继承都是不可见的。这里的不可见是指基类的私
有成员还是被继承到了派生类对象中，但是语法上限制派生类对象不管在类里面还是类外面
都不能去访问它

2 若是基类成员被派生类继承后，在类外不能被访问，但是在类里可以被访问，就将基类成员的访问限定符定义为protected，保护成员限定符是因继承才出现的

3 观察上表可发现：基类的private成员在派生类中都不可见，基类的其他成员在子类的访问方式 == Min(成员在基类的访问限定符，继承方式)，public > protected> private
4 使用关键字class时默认的继承方式是private，使用struct时默认的继承方式是public，但是建议显示写出继承方式

5 实际中public继承使用较为频繁，protected继承和private继承几乎很少使用，所以上表的重心可以进一步缩小：

 若是将父类的成员变量的访问限定符由protected改成public，那么继承到子类中，就成为子类的public成员，在类外也能被访问

 

 在对继承有一个大概的了解之后，我们再来想一下如何实现一个不能被继承的类？

答案：私有化父类的构造函数（间接法）/ 使用c++11新增的关键字final（直接法）

因为子类对象被创建就会自动调用子类的构造函数，也就一定会先调用父类的构造函数，如果父类的构造函数是私有的，那么子类继承后是不可见的，也就无法访问，也就无法初始化父类的那部分成员

正常情况：子类可以继承父类

class A
{
public:
	A()
	{}

protected:
	int _a;
	int _b;
};

class B : public A
{
public:
	void func()
	{
		_a++;
	}
};

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

将父类的构造函数私有后：

 

 此外C++11 新增final关键字，修饰父类，让父类直接不能被继承

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

1 派生类对象可以赋值给基类的对象 / 基类的指针 / 基类的引用 （因为父类有的子类全都有）
形象点的说法叫切片/切割，即把派生类中父类那部分切出来赋值过去，但是这只限制于形象的理解，并不是真的切割/切片

public继承，父类和子类是is-a的关系，认为子类是特殊的父类，子类对象赋值给父类的对象/父类的指针/父类的引用，我们认为是天然，中间不产生临时变量，叫做父子类赋值兼容规则（切割/切片）

class Person
{
protected:
	string _name; 
	string _sex; 
	int _age; 
};

class Student : public Person
{
public:
	int _No; // 学号
};

2 基类对象不能赋值给派生类对象，因为子类有的是父类没有的

3 基类的指针或者引用可以通过强制类型转换赋值给派生类的指针或者引用，但是必须是基类
的指针是指向派生类对象时才是安全的

继承中的作用域
 

1 在继承体系中基类和派生类都有独立的作用域

   所以父类和子类可以有同名成员，因为他们是独立作用域

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

对于同名成员，默认直接访问是子类的，子类同名成员隐藏父类同名成员

3 继承中，同名的成员函数，函数名相同就构成隐藏，不管参数和返回值

class Person
{
protected:
	string _name = "小李子"; // 姓名
	int _num = 111; // 身份证号
};

class Student : public Person
{
public:
	void Print()
	{
		cout << " 姓名:" << _name << endl;
		cout << " 身份证号:" << Person::_num << endl;//显示访问被隐藏的父类的_num
		cout << " 学号:" << _num << endl;//使用的是子类的_num,父类的_num被隐藏了
	}
protected:
	int _num = 999; // 学号 隐藏了父类中的同名成员变量_num
};


int main()
{
	Student s1;
	s1.Print();

//B中的fun和A中的fun不构成重载，因为不在同一作用域
//B中的fun和A中的fun构成隐藏，成员函数满足函数名相同就构成隐藏
class A
{
public:
	void fun()
	{
		cout << "func()" << endl;
	}
};
class B : public A
{
public:
	void fun(int i)
	{
		A::fun();//显示调用隐藏的父类成员函数
		cout << "func(int i)->" << i << endl;
	}
};

int main()
{
	B b;
	b.fun(10);
    b.A::func();//调用被隐藏的父类成员函数
}

 

4 在继承体系里面最好不要定义同名的成员

派生类的默认成员函数
 

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

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

3 派生类的operator=必须要调用基类的operator=完成基类的赋值

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

5 派生类对象初始化先调用基类构造再调派生类构造（构造：先父后子）

6 派生类对象析构清理先调用派生类析构再调基类的析构（析构：先子后父，为了保证析构安全）

   父类析构函数不需要显示调用，子类析构函数结束时会自动调用父类析构 以保证保证先子后父

   若是父类的析构函数先调用，那么父类那部分的成员销毁，但是在调用子类的析构函数时，是有可能访问父类的成员的，所以先父后子调用析构的做法存在危险性

但是子类的析构函数先调用就不用担心有危险了，因为此时父类成员还未被销毁，在子类的析构函数调用期间是可以被访问的，没有任何问题，然后调用父类的析构函数，因为父类的析构函数不会访问子类成员，所以先子后父调用析构的做法是足够安全的，故而为了保证调用析构时的顺序一定是先子后父亲，所以不需要我们显示去调用父类析构，这项工作由编译器自主完成：当子类析构函数调用结束后自动调用父类的析构函数

7 由于多态的原因，析构函数统一会被处理成destructor（），由于同名，所以父子类的析构函数会构成隐藏

class Person
{
public:
	Person(const char* name = "peter")
		: _name(name)
	{
		cout << "Person()" << endl;
	}
	Person(const Person& p)
		: _name(p._name)
	{
		cout << "Person(const Person& p)" << endl;
	}
	Person& operator=(const Person& p)
	{
		cout << "Person operator=(const Person& p)" << endl;
		if (this != &p)
			_name = p._name;
		return *this;
	}
	~Person()
	{
		cout << "~Person()" << endl;
	}
protected:
	string _name; // 姓名
};
class Student : public Person
{
public:
	Student(const char* name, int num)
		: Person(name)
		, _num(num)
	{
		cout << "Student()" << endl;
	}
	Student(const Student& s)
		: Person(s)
		, _num(s._num)
	{
		cout << "Student(const Student& s)" << endl;
	}
	Student& operator = (const Student& s)
	{
		cout << "Student& operator= (const Student& s)" << endl;
		if (this != &s)
		{
			Person::operator =(s);
			_num = s._num;
		}
		return *this;
	}
	~Student()
	{
		cout << "~Student()" << endl;
	}
protected:
	int _num; //学号
};

Student s1("jack", 18);

Student s1("jack", 18);
Student s2(s1);

 

继承与友元
 

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

继承与静态成员
 

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

class Person
{
public:
	Person() { ++_count; }
protected:
	string _name; // 姓名
public:
	static int _count; // 统计人的个数。
};
int Person::_count = 0;
class Student : public Person
{
protected:
	int _stuNum; // 学号
};

class Graduate : public Student
{
protected:
string _seminarCourse; // 研究科目
};


int main()
{
	Student s1;
	Student s2;
	Student s3;
	Graduate s4;
	cout << " 人数 :" << Person::_count << endl;
	Student::_count = 0;
	cout << " 人数 :" << Person::_count << endl;
	return 0;
}

复杂的菱形继承及菱形虚拟继承
 

单继承：一个子类只有一个直接父类时称这个继承关系为单继承

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

菱形继承：菱形继承是多继承的一种特殊情况
 

class Person
{
public:
	string _name; // 姓名
};
class Student : public Person
{
protected:
	int _num; //学号
};
class Teacher : public Person
{
protected:
	int _id; // 职工编号
};
class Assistant : public Student, public Teacher
{
protected:
	string _majorCourse; // 主修课程
};

 

从上图可以看出菱形继承有数据冗余和二义性的问题。在Assistant的对象中Person成员会有两份
 

    // 这样会有二义性无法明确知道访问的是哪一个
	Assistant a;
	a._name = "peter";

    // 需要显示指定访问哪个父类的成员可以解决二义性问题，但是数据冗余问题无法解决
	a.Student::_name = "xxx";
	a.Teacher::_name = "yyy";

虚拟继承可以解决菱形继承的二义性和数据冗余的问题
在以上实例中，在Student和Teacher继承Person时使用虚拟继承，即可解决问题

下面以实例来演示菱形继承内存对象成员模型：存在数据冗余问题与二义性

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 d;
	d.B::_a = 1;
	d.C::_a = 2;
	d._b = 3;
	d._c = 4;
	d._d = 5;
	return 0;
}

 调用内存窗口观察d对象：

下面演示菱形虚拟继承的内存对象成员模型：

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 d;
	d.B::_a = 1;
	d.C::_a = 2;
	d._b = 3;
	d._c = 4;
	d._d = 5;
	return 0;
}

 调用内存窗口观察d对象：

 在vs中，D对象中将A放到的了对象组成的最下面，这个A由B和c共享

B和C要找到公共的A：通过各自的虚基表指针

此指针指向一个虚基表，虚基表中存有偏移量，通过偏移量可以找到公共的A

 总结：

1 一般不建议设计出多继承，更一定不要设计出菱形继承

2  继承和组合：

a public继承是一种is-a的关系。即每个派生类对象都是一个基类对象

b 组合是一种has-a的关系。假设B组合了A，每个B对象中都有一个A对象
c 优先使用对象组合，而不是类继承：

 继承允许你根据基类的实现来定义派生类的实现。这种通过生成派生类的复用通常被称
为白箱复用(white-box reuse)。术语“白箱”是相对可视性而言：在继承方式中，基类的
内部细节对子类可见 。继承一定程度破坏了基类的封装，基类的改变，对派生类有很
大的影响。派生类和基类间的依赖关系很强，耦合度高

对象组合是类继承之外的另一种复用选择。新的更复杂的功能可以通过组装或组合对象
来获得。对象组合要求被组合的对象具有良好定义的接口。这种复用风格被称为黑箱复
用(black-box reuse)，因为对象的内部细节是不可见的。对象只以“黑箱”的形式出现。
组合类之间没有很强的依赖关系，耦合度低。优先使用对象组合有助于你保持每个类被
封装。
 

// Car和BMW Car和Benz构成is-a的关系
class Car 
{
protected:
	string _colour; // 颜色
	string _num; // 车牌号
};

class BMW : public Car 
{
public:
	void Drive() 
	{ 
		cout << "好开" << endl;
	}
};

class Benz : public Car 
{
public:
	void Drive() 
	{ 
		cout << "舒适" << endl; 
	}
};


// Tire和Car构成has-a的关系
class Tire 
{
protected:
	string _brand ; // 品牌
	size_t _size ; // 尺寸
};

class Car 
{
protected:
	string _colour ; // 颜色
	string _num ; // 车牌号
	Tire _t; // 轮胎
};

//继承
class A
{
public:
	void func()
	{}
protected:
	int _a;
};

class B : public A
{
public:
	void f()
	{
		func();//可以复用A类的成员函数
		_a++;//复用A类的成员变量
	}
protected:
	int _b;
};

// 组合
class C
{
public:
	void func()
	{}
protected:
	int _c;
};

class D
{
public:
	void f()
	{
		_c.func();//只能使用C类的public成员
	}
protected:
	C _c;
	int _d;
};