C++进阶：继承

目录

一.继承的概念及定义

1.1继承的概念

1.2继承的定义

继承父类成员访问方式的变化

​编辑

 1.3继承类模版

按需实例化

二.父类和子类的赋值兼容转换

 三.继承中的作用域

四.子类的默认成员函数

4.1四个常见的默认构造函数

4.2不能被继承的类

五.继承与友元

六.继承与静态成员

七.继承类型

7.1继承模型

7.2虚继承

7.3多继承指偏移问题

八.继承和组合

---

一.继承的概念及定义

1.1继承的概念

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

假如我有两个类Student和Teacher，这两个类可能有些属性是相同的，比如它们都有名字，性别等等，但是它们也有一些特点是独有的，比如学生的学号，老师的职工号等等。

class Student
{
public:
	void identity()
	{
		// ...
	}
	void study()
	{
		// ...
	}

protected:
	string _name = "peter"; // 姓名 
	string _address; // 地址 
	string _tel; // 电话 
	int _age = 18; // 年龄 
	int _stuid; // 学号 
};

class Teacher
{
public:
	void identity()
	{
		// ...
	}
	void teaching()
	{
		//...

	}

protected:
	string _name = "张三"; // 姓名 
	int _age = 18; // 年龄 
	string _address; // 地址 
	string _tel; // 电话 
	string _title; // 职称 
};

int main()
{
	return 0;
}

这里我们就可以把他们的共有属性结合起来：

class Person
{
public:
	//进入学校的身份验证
	void identity()
	{
		cout << "void identity()" << _name << endl;
	}
protected:
	string _name = "张三"; // 姓名 
	string _address; // 地址 
	string _tel; // 电话 
	int _age = 18; // 年龄
};
class Student :public Person
{
public:
	// 学习 
	void study()
	{
		// ...
	}
protected:
	int _stuid; // 学号
};
class Teacher :public Person
{
public:
	// 授课 
	void teaching()
	{
		//...

	}

private:
	string title; // 职称 
};

Student和Teacher就分别继承了Person的属性。

1.2继承的定义

在上面的继承中，Person叫做父类（也叫基类），Student和Teacher叫做子类（也叫派生类）。

public叫做继承方式： 

注意和访问限定符的区别。

继承父类成员访问方式的变化

1. 父类private成员在子类中无论以什么方式继承都是不可见的。这里的不可见是指父类的私有成员还是被继承到了子类对象中，但是语法上限制子类对象不管在类里面还是类外面都不能去访问它。（所以我们就经常用protected）

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

3. 父类的私有成员在子类都是不可见。父类的其他成员在子类的访问方式 == min(成员在父类的访问限定符，继承方式)，public  > protected > private。

4. 使用关键字class时默认的继承方式是private，使用struct时默认的继承方式是public，不过最好显示的写出继承方式。

5. 在实际运用中一般使用都是public继承，几乎很少使用protetced/private继承，也不提倡使用 protetced/private继承，因为protetced/private继承下来的成员都只能在子类的类里面使用，实际中扩展维护性不强。

 1.3继承类模版

#define CONTAINER std::deque

template<class T>
class stack : public CONTAINER<int>
{
public:
	void push(const T& x)
	{
		// 父类是类模板时，需要指定一下类域， 
		// 否则编译报错:error C3861: “push_back”: 找不到标识符 
		// 因为stack<int>实例化时，也实例化vector<int>了 
		// 但是模版是按需实例化，push_back等成员函数未实例化，所以找不到 
		CONTAINER<int>::push_back(x);
	}
	void pop()
	{
		CONTAINER<T>::pop_back();
	}	
	const T& top()
	{
		return CONTAINER<T>::back();
	}	
	bool empty()
	{
		return CONTAINER<T>::empty();
	}
};

 这里需要单独说一下上面的按需实例化的问题，如果我们在调用push_back的时候不写CONTAINER<int>::的话，会报错（只有类模版这样，比如上面1.1写的学生和教师调用Person的身份验证就不会报错）。这里就是牵扯到按需实例化的问题。

按需实例化

在main函数中，假如我们创建了一个stack<int > s。一个s对象，在实例化stack的同时，也会把vector给实例化，但是需要特别注意的一点就是，它不会实例化push_back，只用当我们使用push_back的时候才会实例化它。调用一个没有实例化的函数就会报错。（这也是为什么，有时候在一个类中的函数的某个语句，我们甚至没有加“；”编译器也不会报错的原因）

在编译器的更新过程中，这种问题也有升级，不依赖模版的函数调用等等情况，编译器也会去检查。

我并没有func()函数：

//不依赖模版会检查报错
template<class T>
class a
{
	void push(const T& x)
	{
		func();
	}
};
//依赖模版不会报错
template<class T>
class a
{
	void push(const T& x)
	{
		x.func();
	}
};

二.父类和子类的赋值兼容转换

1. public继承的子类对象可以赋值给父类的对象/父类的指针/父类的引用。这里有个形象的说法叫 切片或者切割。寓意把子类中父类部分切来赋值过去。

2. 父类对象不能赋值给子类对象。

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

比如： 

class Person
{
protected:
	string _name; // 姓名 
	string _sex; // 性别 
	int _age; // 年龄 
};

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

int main()
{
	Student sobj;
	// 1.子类对象可以赋值给父类对象/指针/引用 
	Person pobj = sobj;
	Person* pp = &sobj;
	Person& rp = sobj;

	//2.父类对象不能赋值给子类对象，这里会编译报错 
	//sobj = pobj;

	return 0;
}

 三.继承中的作用域

1.在继承体系中父类和子类都有独立的作用域。

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

3. 需要注意的是如果是成员函数的隐藏，只需要函数名相同就构成隐藏。

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

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

class Student : public Person
{
public:
	void Print()
	{
		cout << "姓名:" << _name << endl;
		cout << "身份证号:" << Person::_num << endl;//想访问父类的就必须指明
		cout << "学号:" << _num << endl;
	}

protected:
	int _num = 999; // 学号 
};

四.子类的默认成员函数

4.1四个常见的默认构造函数

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

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

3. 子类的operator=必须要调用父类的operator=完成父类的复制。需要注意的是子类的operator=隐 藏了父类的operator=，所以显示调用父类的operator=，需要指定父类作用域。

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

5. 子类对象初始化先调用父类构造再调子类构造。

6. 子类对象析构清理先调用子类析构再调父类的析构。

7. 因为多态中⼀些场景析构函数需要构成重写，重写的条件之⼀是函数名相同。那么编译器会对析构函数名进行特殊处理，处理成destructor()，所以父类析构函数不加 virtual的情况下，子类析构函数和父类析构函数构成隐藏关系

class Person
{
public:
	Person(const char* name="xxx")
		:_name(name)
	{
		cout << "Person(const char* name)" << 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;
	}
private:
	string _name;
};
class Student:public Person
{
public:
	Student(const char* name, int num, const char* addrss)
		:Person(name)//注意这里不允许直接初始化父类的成员，写成_name(name)是错误的
		,_num(num)
		,_addrss(addrss)
	{}
	// 严格说Student拷贝构造默认生成的就够用了
	// 如果有需要深拷贝的资源，才需要自己实现
	Student(const Student& s)
		:Person(s)//调用父类的拷贝构造，这里就用到了切割
		, _num(s._num)
		, _addrss(s._addrss)
	{
		// 深拷贝
	}

	// 严格说Student赋值重载默认生成的就够用了
	// 如果有需要深拷贝的资源，才需要自己实现
	Student& operator=(const Student& s)
	{
		if (this != &s)
		{
			// 父类和子类的operator=构成隐藏关系，所以要指明
			Person::operator=(s);

			_num = s._num;
			_addrss = s._addrss;
		}

		return *this;
	}
	// 严格说Student析构默认生成的就够用了
	// 如果有需要显示释放的资源，才需要自己实现
	// 析构函数都会被特殊处理成destructor() 
	~Student()
	{
		// 子类的析构和父类析构函数也构成隐藏关系
		// 规定：不需要显示调用，子类析构函数之后，会自动调用父类析构
		// 这样保证析构顺序，先子后父，显示调用取决于实现的人，不能保证
		// 先子后父
	    //Person::~Person();
		//delete _ptr;
	}

private:
	int _num = 1; //学号
	string _addrss = "中国";

	int* _ptr = new int[10];
};

这里需要再说一下，一定注意，析构是先子后父，并且会自动调用父类的。

4.2不能被继承的类

两种方法：

1：父类的构造函数私有，子类的构成必须调用父类的构造函数，但是父类的构成函数私有化以 后，子类看不见就不能调用了，那么子类就无法实例化出对象。

2：C++11新增了⼀个final关键字，final修改父类，子类就不能继承了。

class Person final
{
public:
	void func()
	{
		//...
	}
protected:
	int _num;
};
class Student:public Person
{
public:
protected:
	int _num;
};

五.继承与友元

友元关系不能继承：

class Student;

class Person
{
public:
	friend void Display(const Person& p, const Student& s);
protected:
	string _name; // 姓名 
};

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

void Display(const Person& p, const Student& s)
{
	cout << p._name << endl;
	cout << s._stuNum << endl;
}

int main()
{
	Person p;
	Student s;
	// 编译报错：error C2248: “Student::_stuNum”: 无法访问 protected 成员 
	// 解决方案：Display也变成Student 的友元即可 
	Display(p, s);

	return 0;
}

这里除了友元还需要注意的一点是上面的那个声明，因为编译器在遇到变量的时候会向上查找，找不到就会报错，所以就要加一个声明。

六.继承与静态成员

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

class Person
{
public:
	string _name;
	static int _count;
};

int Person::_count = 0;

class Student : public Person
{
protected:
	int _stuNum;
};

int main()
{
	Person p;
	Student s;
	// 这里的运行结果可以看到非静态成员_name的地址是不⼀样的 
	// 说明子类继承下来了，父子类对象各有⼀份 
	cout << &p._name << endl;
	cout << &s._name << endl;
	// 这里的运行结果可以看到静态成员_count的地址是⼀样的 
	// 说明子类和父类共用同⼀份静态成员 
	cout << &p._count << endl;
	cout << &s._count << endl;
	// 公有的情况下，父子类指定类域都可以访问静态成员 
	cout << Person::_count << endl;
	cout << Student::_count << endl;
	return 0;
}

七.继承类型

7.1继承模型

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

多继承：一个子类有两个或以上直接父类时称这个继承关系为多继承，多继承对象在内存中的模型 是，先继承的父类在前面，后面继承的父类在后面，子类成员在放到最后面。

菱形继承：菱形继承是多继承的一种特殊情况。菱形继承的问题，从下面的对象成员模型构造，可以看出菱形继承有数据冗余和二义性的问题，在Assistant的对象中Person成员会有两份。支持多继承就一定会有菱形继承，像Java就直接不支持多继承，规避掉了这里的问题，所以实践中我们也是不建议设计出菱形继承这样的模型的。  

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()
{
	// 编译报错：error C2385: 对“_name”的访问不明确 
	Assistant a;
	a._name = "peter";
	// 需要显示指定访问哪个类的成员可以解决二义性问题，但是数据冗余问题无法解决 
	a.Student::_name = "xxx";
	a.Teacher::_name = "yyy";
	return 0;
}

这里的数据冗余就是我们在继承的时候会生成多份那个类，导致数据冗余。二义性就是上面的不知道调用哪一个，需要指定调用。 

7.2虚继承

可以使用虚继承避免菱形继承的冗余和二义性：

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()
{
	// 编译报错：error C2385: 对“_name”的访问不明确 
	Assistant a;
	a._name = "peter";
	// 需要显示指定访问哪个类的成员可以解决二义性问题，但是数据冗余问题无法解决 
	a.Student::_name = "xxx";
	a.Teacher::_name = "yyy";
	return 0;
}

这里我们就没有冗余了，它们共用一个_name。

7.3多继承指偏移问题

class Base1
{
	public: int _b1;
};

class Base2 
{
	public: int _b2; 
};

class Derive : public Base1, public Base2 
{
	public: int _d; 
};
int main()
{
	Derive d;
	Base1* p1 = &d;
	Base2* p2 = &d;
	Derive* p3 = &d;

	return 0;
}

求p1，p2和p3地址之间有什么区别？

p1和p3地址相同，p2刚好大4.

 

Base1是先继承的所以放在前面。相差的是一个Base的int大小，所以相差4.

八.继承和组合

1. public继承是一种is-a的关系。也就是说每个子类对象都是一个父类对象。

2. 组合是一种has-a的关系。假设B组合了A，每个B对象中都有一个A对象。

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

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

比如组合：

class Tire 
{
protected:
	string _brand = "Michelin"; // 品牌 
	size_t _size = 17; // 尺寸
};

class Car 
{
protected:
	string _colour = "白色"; // 颜色 
	string _num = "陕ABIT00"; // ⻋牌号 
	Tire _t1; // 轮胎 
	Tire _t2; // 轮胎 
	Tire _t3; // 轮胎 
	Tire _t4; // 轮胎 
};

继承：

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

// Car和BMW/Benz更符合is-a的关系 
class Benz : public Car {

public:
	void Drive() { cout << "好坐-舒适" << endl; }
};

实现栈的话两种都可以。