(10)C++继承初始_c++继承构造函数初始化

---

继承

---

基础涵盖
1.作用：增加代码的重用性
2.形式：包括基类/父类和派生类/子类

class CPeolpe//声明基类/父类
{
public:
	void study()
		cout << "goto study" << endl;
};
class Cchlid : public CPeolpe  //继承父类的形式
{
public:
	void school()
		cout << "goto school" << endl;
};
1
2
3
4
5
6
7
8
9
10
11
12

3.可以继承很多层：原理都是一样的

class Cman : CPeolpe,Cchlid  //继承多类的形式 
1

4.调用
当一个子类继承了父类，那父类的所有东西都属于这个子类了
即可以通过子类创建的对象来调用父类。
(1)

	Cchlid chlid;//子类创建对象
	chlid.study ();
1
2

(2)指针调用

	Cchlid *chlid1 = new Cchlid;
	chlid1->study();
1
2

注意：
(1)子类对象和子类子类对象之间没关系
(2)继承后对父类没有任何影响，改变
继承限定词
1.public继承限定词(类内的访问修饰符)
class Cchlid : public CPeolpe用public时
父类里用的什么修饰符，在子类就是什么修饰符

class CPeolpe//声明基类/父类
{
public:
	void study()
	{
		cout << "goto study" << endl;
	}
protected:
	int a = 12;
};
//这里就不能调用a,因为在子类中也是protected成员
1
2
3
4
5
6
7
8
9
10
11

2.protected继承限定词
将父类的public降为protected,父类其他不变
3.private继承限定词
父类的所有成员全变私有
继承的构造函数调用顺序
1.继承构造的调用顺序，先调用父类的，再调用子类的

class Teach
{
public:
	int a;
	Teach()
	{
		a = 30;
	}
	void print1()
	{
		cout << a << endl;
	}
};
class Student : public Teach
{
public:
	int b;
	Student()
	{
		b = 12;
	}
	void print2()
	{
		print1();
		cout << b << endl;
	}
};
//主函数调用
	Student xiaoming;
	xiaoming.print2();
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

2.在子类Student中，要先把父类的成员实际化(申请空间)，再把子类的成员实际化；
3.若再创建一个子类Chlid，把Student当作父类，那他们的分布顺序是先实际化Teach再实际化Student最后实际化Chlid。
4.分布情况决定了构造函数的调用顺序
有参构造函数的继承的调用
1.父类构造函数参数在子类构造函数参数列表处调用

Cson():Cfather(1)  //子类构造函数
{
	cout << "Sonclass" << endl;
}
1
2
3
4

2.没有参数时实际上是Cson():Cfather()这样的
3.若再有一个Cson的子类Gson
证明，只关注自己的父类即可

Cson():Cfather()
Gson():Gson()
1
2

4.也可以用参数传递

class Cfather
{
public:
	Cfather(int a)
	{
		cout << "fatherclass" << endl;
	}
};
class Cson : public Cfather
{
public:
	int b;
	Cson(int b):Cfather(b) //在子类的参数列表处传递父类构造函数的参数
	{
		b = 12;
	}
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

5.多个构造函数重载时，根据参数个数来判断
析构函数与继承
调用顺序与构造函数相反，先调用子类的子类，最后调用父类

class Cgrandfarther
{
public:
	Cgrandfarther()
	{
		cout << "grandfarther" << endl;
	}
	~Cgrandfarther()
	{
		cout << "grandfarther" << endl;
	}
};
class Cfarther : public Cgrandfarther
{
public:
	Cfarther()
	{
		cout << "farther" << endl;
	}
	~Cfarther()
	{
		cout << "farther" << endl;
	}
};
class Cson : public Cfarther
{
public:
	Cson()
	{
		cout << "son" << endl;
	}
	~Cson()
	{
		cout << "son" << endl;
	}

};
//主函数调用
Cson son;
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

覆盖
1.概念
父类和子类出现同名成员时，C++采用的一种处理方式
2.同名情况
(1)数据成员同名：使用子类的成员，覆盖父类的成员

class Cfarther
{
public:
	int a;
	Cfarther()
	{
		a = 10;
	}
	void print()
	{
		cout << a << endl;
	}
};
class Cson:public Cfarther
{
public:
	int a;
	Cson()
	{
		a = 12;
	}
	void print()
	{
		cout << a << endl;
	}
};
//主函数调用
	Cson son;
	son.print();
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

那如何使用父类的a呢？
解决方案：
类内，使用类名作用域

	void print()
	{
		cout << son.Cfarther::a << endl;
	}
1
2
3
4

类外，使用类名作用域区分

//主函数调用
	cout << son.Cfarther::a << endl;  //父类a的值
1
2

(2)函数成员同名：也是使用子类成员覆盖父类
解决方案：类名作用域

son.Cfarther::print();
1

注意：
1.虽然继承了过来，但函数是覆盖关系，并不是重载关系
不管有没有参数，只要名字相同就覆盖
2.友元函数，写在哪个类里面，那个类才能使用私有成员，与继承无关
即友元不能被继承
3.静态成员不管写在父类，还是子类。都是公有的。始终只有一份。