C++的继承

C++的继承

1. 继承的概念和使用

1.1继承的概念
继承是面向对象程序设计使用代码可以复用的最重要的手段，它允许程序员在保持原有类特性的基础上进行扩展，增加功能，这样产生新的类，称为派生类。
在下列代码中，继承后父类的Person成员（成员函数+成员变量）都会变成子类的一部分。继承呈现面向对象程序设计的层次结构，体现了由简单到复杂的认知过程，继承是类设计层次的复用。

class Person
{
public:
	void print()
	{
		cout << "name:" << _name << endl;
		cout << "age:" << _age << endl;
	}
protected:
	string _name = "Mary";
	int _age = 21;
};

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

1.2 继承定义
1.2.1定义格式
下面我们看到Person是父类，也称作基类。Student是子类，也称作派生类下面我们看到Person是父类，也称作基类。Student是子类，也称作派生类。

1.2.2继承关系与访问限定符
继承方式：public继承、protected继承、private继承
访问限定符：public访问、protected访问、private访问
继承基类成员访问方式

注意：
（1）基类private成员在派生类中无论以什么方式继承都是不可见的，这里的不可见是指基类的私有成员还是被继承到了派生类对象中，但是语法上限制派生类对象不管在类里面还是类外面都不能去访问它。
（2）基类private成员在派生类是不能被访问的，如果类成员不想在类外直接被访问，但需要在派生类中能够访问，就定义为protected。这样可以看出保护成员限定符是因继承才出现的。
（3）使用关键字class是默认的继承方式是private，使用struct是默认的继承方式是public。不过最好显示定义集成方式。
（4）在实际运用中一般使用的都是public继承，几乎很少使用protected/private继承，因为protected/private继承下来的成员都只能在派生类的类里面使用，实际扩展维护性不强。

2.基类和派生类对象赋值转换（public继承方式）

（1）派生类对象可以赋值给基类的对象
（2）让基类的指针或者引用直接指向子类的对象
（3）基类对象不能直接赋值给派生类对象
（4）基类的指针可以通过强制类型转换赋值给派生类的指针。但是必须是基类的指针是指向派生类对象时才是安全的。

class Person
{
protected:
	string _name;//姓名
	string _sex;//性别
	string _age;//年龄
};
class Student : public Person
{
public:
	int _number;//学号
};
int main()
{
	Student s;
	//子类对象可以直接赋值给父类对象
	Person p = s;
	//基类指针或者引用直接指向子类的对象
	Person* pp = &s;
	Person& rp = s;

	//基类对象不能赋值给派生类对象
	s = p;

	//基类的指针可以通过强制类型转换赋值给派生类的指针
	pp = &s;
	Student* ps = (Student*)pp;//这种状况转换是可以的；
	ps->_number = 1;

	pp = &p;
	Student* ps1 = (Student*)pp;//这种状况转换虽然可以的，但是存在越界访问的问题
	ps1->_number = 1;
}

3.继承中的作用域

（1）在继承体系中基类和派生类都用独立的作用域。
（2）同名隐藏:基类和派生类具有相同名称的成员（成员变量，成员函数），派生类调用相同名称的成员时，优先调用自己的成员。
（3）如果成员变量同名与成员变量类型无关；如果成员变量函数同名，与成员函数无关，都优先调用派生类自己的同名成员。
（4）如果想要调用基类的同名成员，只需在同名成员前增加基类的名称以及作用域限定符即可。
（5）在实际中在继承体系里面最好不要定义同名成员。

//Base中的_num和Derived中的_num构成隐藏关系
//Base中的print和Derived中的print构成隐藏，
//成员函数满足函数名相同就构成隐藏
class  Base
{
public:
	void print()
	{
		cout << "hello" << endl;
	}
protected:
	int _num = 112;
};
class Derived : public Base
{
public:
	void print()
	{
		Base::print();
		cout << "world" << endl;
	}
protected:
	int _num = 110;
};

void test()
{
	Base b;
	b.print();
}

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

1.派生类的构造函数必须调用基类的构造函数初始化基类的那一部分成员。如果基类没有默认的构造函数，则必须在派生类构造函数的初始化列表阶段显示调用。
2. 派生类的拷贝构造函数必须调用基类的拷贝构造完成基类的拷贝初始化。
3. 派生类的operator=必须要调用基类的operator=完成基类的复制。如果内存中涉及资源管理问题，派生类需要将自己的赋值运算符重载显示给出，必须在其内部显示调用基类的赋值运算符重载，完成基类部分的赋值，在完成自己特有成员的赋值。
4. 派生类的析构函数会在被调用完成后自动调用基类的析构函数清理基类成员。因为这样才能保证派生类对象先清理派生类成员再清理基类成员的顺序。
5. 派生类对象初始化先调用基类构造再调派生类构造。
6. 派生类对象析构清理先调用派生类析构再调基类的析构。

//基类
class Base
{
public:
	//构造函数
	Base(const int b = 1)
		:_b(b)
	{
		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;
	}
	//析构函数
	~Base()
	{
		cout << "~Base()" << endl;
	}
protected:
	int _b;
};
//派生类
class Derived : public Base
{
public:
	//构造函数
	Derived(const int b, int d)
		:Base(b)
		, _d(d)
	{
		cout << "Derived()" << endl;
	}
	//拷贝构造函数
	Derived(const Derived& d)
		:Base(d)
		, _d(d._d)
	{
		cout << "Derived(const Derived& d)" << endl;
	}
	//运算符重载
	Derived& operator=(const Derived& d)
	{
		if (this != &d)
		{
			Base::operator=(d);
			_d = d._d;
		}
		return *this;
	}
	//析构函数
	~Derived()
	{
		cout << "~Derived()" << endl;
	}
protected:
	int _d;
};

int main()
{
	Derived d1(1,2);
	Derived d2(d1);
	Derived d3(3,4);
	d1 = d3;
	return 0;
}

5.继承与友元函数，静态成员

5.1继承与友元函数
友元关系不能被继承，基类友元不能访问子类私有和保护成员

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

class Person
{
public:
	Person()
	{
		++_count;
	}
protected:
	string _name;
public:
	static int _count;//统计人的个数
};
int Person::_count = 0;
class Student : public Person
{
protected:
	int _stNum;//学号
};
class  Graduate : public Student
{
protected:
	string _seminarCourse;//研究项目
};
void Test()
{
	Student s1; 
	Student s2;
	Student s3;
    Graduate s4;
	cout << " 人数 :" << Person::_count << endl;   
	Student::_count = 0;
	cout << " 人数 :" << Person::_count << endl;
}

6.菱形虚拟继承

6.1继承的类别
（1）单继承：一个子类只有一个直接的父类

（2）多继承：一个子类有两个或者两个以上直接父类

（3）菱形继承：菱形继承是多继承的一种特殊情况，是单继承+多继承

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;
};

int main()
{
	Assistant  a;
	//这样存在二义性无法明确知道访问的是哪一个
	a._name = "Lily";
     // 需要显示指定访问哪个父类的成员可以解决二义性问题，但是数据冗余问题无法解决    
    a.Student::_name = "xxx";   
    a.Teacher::_name = "yyy"; 
}

对于上面代码菱形继承中存在数据冗余和二义性问题。可以利用虚拟菱形继承来进行解决。在上面的继承关系中，在Student和Teacher的继承Person是使用虚拟继承，就可以解决问题。注意：虚拟继承不要在其他地方去使用。
**虚拟继承：**编译器新增加4个字节，在构造对象时，将地址填充前4个字节。

class Person
{
public :
	string _name;
};
class Student : virtual public Person
{
protected:
	int _num;
};
class Teacher : virtual public Person
{
protected:
	int _id;//身份证号
};
class Assistant : public Student, public Teacher
{
protected:
	string _majorCourse;
};

int main()
{
	Assistant  a;
	a._name = "Lily";
}

虚拟继承与单继承的区别：
1.虚拟继承对象，基类在下，子类部分在上，对象多了4个字节，该4个字节放置的一个地址-----表格（偏移量）派生类相对于自己的偏移量，积累部分相对于派生类起始位置的偏移量。
2.派生类对基类成员的访问方式：（1）从对象前4个字节中取偏移量表格地址。（2）取偏移量表格基类部分相当于派生类对象起始位置的偏移量（3）对象首地址+偏移---->访问派生类中基类成员。