C++中的继承(一)

前言

我们之前说过，继承是面向对象的三大特性。

面向对象的三大特性：
封装、继承、多态。

封装在类和对象体现出。

概念

继承是什么?
继承就是一种类层次的复用,复用就是你的就变成我的.

假设我要实现一个管理系统。
如果按照以前类和对象的方式,单独去实现这个类是很坑的.

每个类都有一些信息, 有些类型之间是有一些共性,
每个类都写,那初始化每个类都要写.

C++创造了一个语法,可以支持继承,支持什么样的继承呢?
把我们公共的属性提取出来,放到一个类里面去,让剩下的类去继承.

我们也可以有些单独独立的信息.

继承是什么样的呢？
首先有很多类。如果这些类都有一些公共的特征，那我们就可以这些
类里面有些特性提取出来，专门放到一个类里面。这个类我们叫做父类。

我们想用这些特征，以前我们要写到一起，我们现在可以继承它。
怎么继承？

我们看一下它的语法：

 //基类/父类
class Person
{
public:
	void Print()
	{
		cout << "name:" << _name << endl;
		cout << "age:" << _age << endl;
	}

private:  
	string _name = "peter"; // 姓名
	int _age = 18;  // 年龄
};

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

继承方式有三种：
公有继承，私有继承，保护继承。

student这个类看起来啥都没有，其实里面啥都有。

它怎么来的？就是从它的父类。
stuent这个类的信息除了有学生的信息还有pesorn的信息，因为它继承了person.
继承也就是父类的我也有。

访问限定符

继承有三种访问限定符，但这三种访问限定符又有三种访问限定方式。
它们两两组合。

这些有什么规律？
它们分成了两组规则。

1.如果是公有成员和保护成员，就取它们继承方式和它的权限里小的那个。(公有大于保护，保护大于私有)
2.私有成员都是不可见。(不可见就是它在这个地方，你不能用)

演示一下，把父类的成员设置成私有
在子类写一个函数。


不可见就是在类里面也用不了，但是它跟私有不一样，私有在类里面可以用。

什么时候我们会定义私有呢？
这东西我不想被子类继承就用私有。

私有和保护在子类才有区别

子类能不能调用父类的函数取访问它？
可以。不可见只是指的是不能直接取访问它，取去调用父类的函数去访问也是可以的。

继承方式也可以像访问限定符一样，可以不写，class默认就是私有继承，struct默认就是公有继承。

实际当中用的最多的，就是这些。

基类和派生类的赋值转换

这是重点中的重点。这块想说的一个问题是什么？

这里会发生什么？d可以赋值给i吗？
可以。发生隐式类型转换，中间会产生临时变量，临时变量具有常性。

接着往下看，一个子类对象能不能给父类对象呢？

可以，但是有没有隐式类型转换的发生呢？
这里只适用于公有继承上，子类可以赋值给父类，这个过程叫做赋值兼容转换。


怎么证明呢？

子类可以赋值给父类，父类能不能给子类？
默认不可以，子类还有一些专有的属性。

继承中的作用域

基类和派生类都有它们独立的作用域。

既然它们都有独立的作用域，那基类和派生类能不能有同名成员呢？

派生类能不能也定义一个_num,可以。
我们c语言就规定不同的作用域可以定义同名的变量。

但是这样，我是会报错还是会访问派生类的呢？

理论上是访问派生类的，根据就近原则。

但是我就想访问基类，有没有什么办法？
指定作用域就可以了，加上域作用限定符。

子类和父类有同名成员，这种情况我们叫做隐藏或者重定义。
隐藏指的是默认情况下他会隐藏父类的成员。

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

class Student : public Person
{
public:
	void Print()
	{
		cout << Person::_num << endl;
		cout << _num << endl;
	}

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

这里有个很坑的东西，经常出选择题考。
以下程序哪个是对的。

这道题的杀手锏是A,为什么是A?
函数名相同，参数不同构成函数重载。
那现在有一个问题，vector里的push_back和list里的push_back呢？
记住，函数重载必须在同一个作用域里面。

编译也没有报错。
虽然它们参数不同，但是它们的关系确实是隐藏。

最麻烦的考法是这样的。
下面这个选什么。

这道题如果是不定向选择，那就是BC.
如果确实要访问A里的fun, 要指定一下作用域

b.A::func();

结论：
如果是成员函数的隐藏，只需要函数名相同就可以构成隐藏。
不需要考虑参数，不需要考虑返回值。

注意在实际中最好不要定义同名的成员，不然自己坑自己。

派生类的默认成员函数

构造函数

派生类的构造函数时怎么玩的呢？
跟我们以前学的有一点点不一样。

注意看这个派生类，我什么都没有写.发生了啥？
如果我们不写，子类会自动调用父类的成员。

如果我们写了呢？


不可以。为什么呢？

在派生类当中，规定了，父类的成员，必须调父类的构造函数初始化。
你不写它也会调用父类的，你写他也会调用父类的。


上面两个都可以编译通过。
你不写他也会调用父类的默认构造，在初始化列表里调。
继承就像子类把父类当作一个自定义类型的整体成员一样。

那如果父类没有默认构造怎么办？
那我们就必须自己写了，自己显示的调用了。

拷贝构造

拷贝构造和前面也是同样的道理。



可以，但是你自己不写他会不会调用父类的拷贝构造。
不会，要初始化父类怎么办？调用父类的拷贝构造。但是要求调用父类的拷贝构造，
是不是要传一个父类的对象过去。

只有子类对象没有父类对象，如何把子类对象父类这一部分拿出来啊。
我们可以用我们之前讲到的切片。

子类对象我也没有父类的那一部分，但是我可以传过去让它自己切就可以了。

这里回答一下之前遗留下来的一个问题？
如果是子类对象给父类对象，这个地方是怎么给过去的？

是memcpy拷贝过去还是怎么拷贝。
这里还是调用了拷贝构造，调用了父类的拷贝构造。

operatro=也是一样的道理



但是这里出现了一个栈溢出的问题，是怎么回事呢？
栈溢出一般都是重复调用，这里教大家一个技巧，可以看调用堆栈

死循环了。为什么？
因为Student类里面的operator=和Person类里面的operator构成隐藏关系。
所以这里自己调用自己了。

指定作用域就可以了

总结一下就是自己干自己的，父类处理父类的。

可不可以不写拷贝构造和赋值呢？
可以，我们之前说过，拷贝构造针对内置类型进行值拷贝或者浅拷贝，
针对自定义类型会调用它的拷贝构造。

析构函数

特点都是先父后子

但是有个非常奇怪的现象，我们调用不了析构。为什么？
由于以后多态的原因，析构不会用这个名字，
析构函数会被处理成Destructro,所以它们会构成隐藏的关系。
所以还是指定一下。

但是这样也不行，父类的析构被调用了两次。

其它成员函数都可以显示调用，唯独析构函数我们不要显示调用。
它可以自动调用，为什么它可以自动？以为它要保证我们的顺序。

自己显示写不能保证调用先子后父的顺序。

为什么要先析构子类再析构父类？
因为父类先定义，子类后定义。

先析构父类，再析构子类有可能会出现野指针的问题。

继承的其他一些细节

友元关系不能被继承。
比如一个类，一个函数是你父类的友元，那是不是你子类的友元呢？
不是。

但是我就是想访问怎么办？
再定义一个友元就可以了。

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

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

void main()
{
	Person p;
	Student s;
	Display(p, s);
}

静态成员是怎么走的？

父类继承有一个_count,子类继承会不会也友一个_count呢？
不会。但是从域的角度，子类可以访问它。

无论你继承多少次，都只有一个_count
静态成员变量属于整个类，它不仅属于父类也属于子类。但是只有同一个。

证明一下：
父类当中的_name和子类当中的_name是不是同一个。
不是，它们的地址是不一样的。
但是_count是同一个。

把父类protected:去掉

下一个问题，这里Peron或者以Peson为继承的子类对象总共创建了多少个对象？
怎么算呢？这里有一个非常巧妙的东西。在父类的构造函数++_count就可以，为什么？
因为子类对象必须调用父类对象去初始化
>

静态的成员所有继承的派生类共享。

实现一个不能被继承的类，如何实现？
最简单的方式就是把它的构造函数私有化，或者析构函数私有化。为什么？
因为构造函数私有了，继承了以后创建不了对象，为什么？
因为子类的构造函数必须去调用父类的构造函数，而父类的构造函数私有，子类调用不了。

A的构造函数私有，B是无论如何也调用不了。
A怎么调用呢？A是有办法的。

class A
{
public:
	static A CreateObj()
	{
		return A();
	}
private:
	A()
	{}
};
class B : public A
{};
int main()
{
//要调用函数首先要创建对象
//我们可以用静态成员函数，就可以直接用类去调用它
	A::CreateObj();
	return 0;
}

友元是能不用就不用。

其实C++正常的继承学到这里也差不多了，但是还有一个大坑，我们留到下篇文章