C++期末复习总结（2）

目录

1.运算符重载
2.四种运算符重载
（1）关系运算符的重载
（2） 左移运算符的重载
（3）下标运算符的重载
 （4）赋值运算符的重载
3.继续的方式
4.继续的对象模型
5.基类的构造
6.名字掩藏和类作用域
7.类继续的特殊关系
8.多态和虚函数

---

1.运算符重载

（1）其实这个知识我们并不是很陌生，我们在C语言学习阶段，就知道了*这个运算符，在我们学习根本的运算的时候，这个运算符就是用来计算乘法的，但是后来我们学到了指针之后，这个运算符就用来表现对于一个指针变量的解引用，这个时候我们就已经认识到了一个运算符的重载功能；
（2）我们通过下面这个现实的场景认识一下什么是c++里面的运算符重载，我们下面的这个代码场景是要为这个超女的分数上面加上30分，这个时候假如我们直接拿这个对象和数字相加，编译器是肯定不会通过的，因为这个编译器不知道要把这个数据加到那个成员变量上面去；
（3）针对这个题目，我们有两种解决方案，第一种就是设置一个函数，实现这个加分的功能，指定这个分数加到那个成员变量上面去，我们原本初始化这个分数是90，加上30分之后这个分数就变成了120分；

1. #include<string>
2. using namespace std;
3. class cgril
4. {
5.         friend void addscore(cgril& g, int score);
6. private:
7.         int m_xw;//超女的行为
8.         int m_score;//超女的分数
9. public:
10.         string m_name;//超女的姓名
11.         cgril()
12.         {
13.                 m_xw = 60;
14.                 m_name = "张三";
15.                 m_score = 90;
16.         }
17.         void show()
18.         {
19.                 cout << "行为：" << m_xw << "分数：" << m_score << "姓名：" << m_name << endl;
20.         }
21. };
22. void addscore(cgril& g, int score)//利用函数，实现加分的功能
23. {
24.         g.m_score = g.m_score + score;
25. }
26. int main()
27. {
28.         //导演的要求就是，每轮表演之后，加上对应的得分
29.         cgril g;
30.         addscore(g, 30);
31.         g.show();
32.         return 0;
33. }

复制代码

（4）上面的这个写法偏向于C的写法，接下来我们看一下怎样使用C++写法实现这个加分的功能，就是把这个函数的名字修改为operator+即可，这个operator是关键字，+就是我们想要重载的运算符 ；
（5）上面的这个运算符重载的根本写法，现实上这个运算符的重载既可以写作成员函数，也可以写作全局函数，当我们实现一个类和一个整形数据加法的时候，假如我们写在成员函数里面，就可以只写一个参数，最后的返回值是*this,这个时候写法是如许的；

1.         cgril& operator+(int score)//利用函数，实现加分的功能
2.         {
3.                 m_score = m_score + score;
4.                 return *this;
5.         }
6. };
7. int main()
8. {
9.         //导演的要求就是，每轮表演之后，加上对应的得分
10.         cgril g;
11.         g = g + 30;
12.         g.show();
13.         return 0;
14. }

复制代码

这个时候，那个对象调用这个成员函数，那个对象就是this指针，如许写在成员函数里面，我们就不需要写这个友元函数了，因为这个在类的里面，我们是可以对于这个私有的成员变量直接进利用用，这个时候g=g+30我们需要把这个返回值设置为这个类的引用类型；
（6）当这个函数写在全局里面时候，有几个操作数，我们就需要写几个操作数，而且这个操作数的数据类型和我们使用的数据类型之间应该是一一对应的，例如我们想要实现这个cgril+int，我们在使用这个加法运算符的时候，我们就必须把这个类写在左边，int类型的数据写在右边，这个序次是不可以改变的；
（7）下面的这些运算符重载的时候必须写在这个成员函数里面去：赋值运算符=    函数调用运算符（ ）   下标运算符[  ]      以及这个指针访问成员操作符->   ；
2.四种运算符重载

（1）关系运算符的重载

关系运算符就是我们常说的这个大于小于和即是这些符号的比力，我们对于两个类之间的比力，需要自己进行运算符的重载；
下面的就是重载了即是号大于号和小于号的运算符重载代码；

1. class student
2. {
3.         string m_name;
4.         int m_cj;//学生成绩
5.         int m_bx;//学生的表现
6.         int m_td;//学生的学习态度
7. public:
8.         student(string name, int cj, int bx, int td)
9.         {
10.                 m_name = name;
11.                 m_cj = cj;
12.                 m_bx = bx;
13.                 m_td = td;
14.         }
15.         bool operator==(const student& s)
16.         {
17.                 if (m_cj + m_bx + m_td == s.m_cj + s.m_bx + s.m_td)
18.                 {
19.                         return true;
20.                 }
21.                 else
22.                 {
23.                         return false;
24.                 }
25.         }
26.         bool operator<(const student& s)
27.         {
28.                 if (m_cj + m_bx + m_td < s.m_cj + s.m_bx + s.m_td)
29.                 {
30.                         return true;
31.                 }
32.                 else
33.                 {
34.                         return false;
35.                 }
36.         }
37.         bool operator>(const student& s)
38.         {
39.                 if (m_cj + m_bx + m_td > s.m_cj + s.m_bx + s.m_td)
40.                 {
41.                         return true;
42.                 }
43.                 else
44.                 {
45.                         return false;
46.                 }
47.         }
48. };
49. int main()
50. {
51.         student s1("张三", 80, 20, 70);
52.         student s2("李四", 70, 70, 30);
53.         if (s1 == s2)
54.         {
55.                 cout << "张三和李四的分数一样" << endl;
56.         }
57.         else
58.         {
59.                 if (s1 < s2)
60.                 {
61.                         cout << "张三比李四的分数低" << endl;
62.                 }
63.                 else
64.                 {
65.                         cout << "张三比李四的分数高" << endl;
66.                 }
67.         }
68.         return 0;
69. }

复制代码

（2） 左移运算符的重载

这个cout有15种重载，因此可以输出各种数据类型的数据，但是cout无法输出我们自己定义的类和对象，这个时候就需要我们对于其进行重载，cout这个对象的返回值现实上就是一个ostream类型的，这个假如是全局函数，就需要两个参数，一个就是cout对象，一个就是我们的自定义类型的对象，假如是成员函数的话，，就只需要一个参数，因为对象自己是隐式通报的，不能出现在形参列表里面；

1. using namespace std;
2. class student
3. {
4.         friend ostream& operator<<(ostream& cout, const student& s);
5.         int m_mark;
6.         string m_name;
7. public:
8.         student()
9.         {
10.                 m_mark = 90;
11.                 m_name = "张三";
12.         }
13.         void show()
14.         {
15.                 cout << "这个同学的姓名是" << m_name << "成绩是：" << m_mark << endl;
16.         }
17. };
18. ostream& operator<<(ostream& cout, const student& s)
19. {
20.         cout << "姓名：" << s.m_name << "  分数：" << s.m_mark << endl;
21.         return cout;
22. }
23. int main()
24. {
25.         student s1;
26.         cout << s1 << endl;
27.         return 0;
28. }

复制代码

成员函数版本的运算符重载：

1. #include<string>
2. using namespace std;
3. class student
4. {
5.         //friend ostream& operator<<(ostream& cout, const student& s);
6.         int m_mark;
7.         string m_name;
8. public:
9.         student()
10.         {
11.                 m_mark = 90;
12.                 m_name = "张三";
13.         }
14.         void show()
15.         {
16.                 cout << "这个同学的姓名是" << m_name << "成绩是：" << m_mark << endl;
17.         }
18.         ostream& operator<<(ostream& cout)
19.         {
20.                 cout << "姓名：" << this->m_name << "  分数：" << this->m_mark << endl;
21.                 return cout;
22.         }
23. };
24. int main()
25. {
26.         student s1;
27.         s1 << cout << endl;
28.         return 0;
29. }

复制代码

 我们可以理解为这个运算符左右两边一共有两个操作数，这个时候我们的自定义类型作为一个隐藏的参数，以是对应的主函数里面这个自定义对象和cout对象的位置需要被改变；
这个时候cout在右边，不是我们想要的效果，因此这个左移运算符的重载，只能写成这个全局函数，不能写成成员函数；
（3）下标运算符的重载

假如没有重载下标运算符，假如我们想要检察这个数组元素，我们就需要自己定义函数，使用这个小括号加上下标的方式表现，但是我们知道这个访问操作符就是中括号，因此下面我们介绍小标访问运算符的重载；

1. #include<iostream>
2. #include<string>
3. using namespace std;
4. class student
5. {
6. private:
7.         string m_zy[3];
8. public:
9.         student()
10.         {
11.                 m_zy[0] = "父母";
12.                 m_zy[1] = "老师";
13.                 m_zy[2] = "朋友";
14.         }
15.         void show()
16.         {
17.                 cout << m_zy[0] << "  " << m_zy[1] << "  " << m_zy[2] << "  " << endl;
18.         }
19.         string& operator[](int ii)
20.         {
21.                 return m_zy[ii];
22.         }
23. };
24. int main()
25. {
26.         student s1;
27.         s1[2] = "知己";
28.         cout << "第三亲密：" << s1[2] << endl;
29.         s1.show();
30.         return 0;
31. }

复制代码

现实在开发的过程中，我们需要有两个版本的重载函数，一个版本是可以对于我们的数据进行修改的，另外的一个就是针对常变量只能调用常函数；

1. #include<iostream>
2. #include<string>
3. using namespace std;
4. class student
5. {
6. private:
7.         string m_zy[3];
8. public:
9.         student()
10.         {
11.                 m_zy[0] = "父母";
12.                 m_zy[1] = "老师";
13.                 m_zy[2] = "朋友";
14.         }
15.         void show()
16.         {
17.                 cout << m_zy[0] << "  " << m_zy[1] << "  " << m_zy[2] << "  " << endl;
18.         }
19.         string& operator[](int ii)
20.         {
21.                 return m_zy[ii];
22.         }
23.         const string& operator[](int ii) const
24.         {
25.                 return m_zy[ii];
26.         }
27. };
28. int main()
29. {
30.         student s1;
31.         s1[2] = "知己";
32.         cout << "第三亲密：" << s1[2] << endl;
33.         s1.show();
35.         const student s2 = s1;
36.         cout << "第三亲密：" << s2[2] << endl;
37.         return 0;
38. }

复制代码

 （4）赋值运算符的重载

赋值运算符其实编译器会提供默认的，我们了解即可，这个我们在重载赋值运算符的时候，需要判定这个时不时会出现自己给自己赋值的情况，这个是合法的，我们直接返回this解引用即可；this就是我们想要赋值的对象；
编译器默认提供的赋值构造函数是浅拷贝，假如这个不存在动态开辟空间，就可以满足需求，否则的话就需要我们自己实现深拷贝；

1. #include<iostream>
2. #include<string>
3. using namespace std;
4. class student
5. {
6. public:
7.         string m_name;
8.         int m_score;
9.         void show()
10.         {
11.                 cout << "姓名：" << m_name << "    年龄：" << m_score << endl;
12.         }
13.         student& operator=(const student& s)
14.         {
15.                 if (this == &s)
16.                         return *this;
17.                 else
18.                 {
19.                         m_name = s.m_name;
20.                         m_score = s.m_score;
21.                 }
22.                 return *this;
23.         }
24. };
25. int main()
26. {
27.         student s1;
28.         s1.m_name = "张三";
29.         s1.m_score = 100;
30.         s1.show();
31.         student s2;
32.         s2 = s1;
33.         s2.show();
34.         return 0;
35. }

复制代码

3.继续的方式

（1）三种不同的继续方式

上面展示的就是三种不同的继续方式，我们假设这个基类有三个成员变量，一个是共有的，一个是受保护的，一个是私有的，经过不同的继续方式之后，这个成员变量的类型会发生什么变革；
第一种就是公有继续，公有继续的时候，我们的父类里面的公有成员照旧公有成员，受保护的成员照旧受保护的成员，私有成员就不存在了；
第二种是受保护的继续，这个时候，原来的公有成员就变成了受保护的成员，原来的父类里面的受保护的成员照旧受保护的，原来的私有成员变量这个时候照旧不存在的；
第三种就是私有的继续，这个时候，原来的父类里面的共有的成员变量和保护的成员变量就是私有的了，原来的父类里面的受保护的成员变量也是不存在的；
（2）我们在这个继续的子类里面是没有办法访问这个所谓的父类里面的私有成员变量的，但是假如我们想要在这个子类里面去访问这个私有的成员变量，可以在父类里面添加共有的函数访问这个私有的成员变量，这个时候我们就可以直接调用这个函数访问父类里面的私有的成员变量；
就像下面的展示那样，我们在子类里面原来是没有办法去访问父类的私有成员变量的，但是我们可以在父类里面创建共有的成员函数，如许在子类里面，我们就可以通过调用这个函数到达间接访问了父类的私有成员变量的目的；

1. class comers
2. {
3. private:
4.         int m_aa;
5. public:
6.         void func()
7.         {
8.                 cout << m_aa << endl;
9.         }
10. };
11. class comerss :public comers
12. {
13. private:
14.         int m_bb;
15. public:
16.         void show()
17.         {
18.                 func();
19.         }
20. };
21. int main()
22. {
23.         comerss c1;
24.         c1.show();
25.         return 0;
26. }

复制代码

（3）我们可以使用using 关键字改变父类的成员变量的访问权限，例如我们可以把这个共有的改变成为受保护的，把这个受保护的改变权限为共有的，这个父类里面的私有的成员变量的权限是没有办法通过这个关键字改变的，因为这个父类里面的私有的成员变量在这个子类里面根本就不会存在，因此这个关键字只对于public权限和protected权限发挥作用；

1. class a
2. {
3. public:
4.         int m_a;
5. protected:
6.         int m_b;
7. private:
8.         int m_c;
9. };
10. class b :public a
11. {
12. public:
13.         using a::m_b;
14. protected:
15.         using a::m_a;
16. };
17. int main()
18. {       
19.         b bb1;
20.         return 0;
21. }

复制代码

通过上面的这个具体的实例，我们就可以把这个父类里面的公有成员变量修改为受保护的，把这个受保护的成员变量修改权限为公有的，当然也可以把他们的权限设置为私有的；
4.继续的对象模型

（1）这个地方是帮助我们了解C++继续语法的底层逻辑，而不是学懂这个底层逻辑，我们只是了解，如许就可以让我们更好理解前面的一些原因；
（2）第一点就是基类在写这个构造函数的时候，会先运行这个父类的构造函数，再去运行这个基类的构造函数，这个我们可以进行尝试，当我们创建两个类，假设是A类和B类，假如A是父类，B是子类，我们把这个A类里面的构造函数设置为私有的，这个时候我们在B这个子类里面去写构造函数就会报错，原因就是我们上面提及到的我们在执行子类的构造函数的时候，会先执行父类的构造函数，这个也是为什么我们建议把这个函数写为共有的，成员变量写为私有的，这个时候我们学习了继续，就可以更好地进行理解；
（3）销毁子类对象的时候，会先执行子类的析构函数，再去执行父类的析构函数，这个和构造函数的执行序次是恰恰相反的；
（4）创建派生类对象的时候，只申请了一次这个内存，申请的内存空间的大小就是基类加上派生类的内存的和，先调用基类的构造函数，初始化基类，再调用派生类的构造函数，初始化派生类，在基类和派生类的构造函数里面，this指针是雷同的地点，派生类和基类都有的成员变量的地点也是一样的；
（5）在C++里面这个成员变量的访问权限只是语法上面的限制，我们可以使用memset函数清零数据，包罗这个私有的成员变量，纵然这个私有的成员变量在类的表面不能被访问；我们可以使用指针突破这个访问权限的限制，以是这个访问权限只是语法上面的一个解释罢了；
5.基类的构造

（1）我们可以使用初始化列表的方式指定要使用的基类的构造函数类型，因为我们前面提及过，这个创建子类也就是派生类的对象的时候，需要先去调用这个父类的构造函数，这个时候假如父类里面有多个构造函数，我们就可以使用初始化列表的方式指定调用基类里面的哪个构造函数；
（2）我们在创建派生类的对象的时候，是使用基类初始化这个基类的成员变量，派生类初始化派生类的成员变量，你大概会问，这些基类的成员变量都被派生类给继续了，为什么不使用派生类初始化基类的成员变量，这个有两点原因；
第一就是我们的基类里面的私有的成员变量我们是无法在这个派生类里面看到的，更别说去对于这个变量进行初始化了；
第二就是这个假如我们在这个派生类里面临于这个基类的成员变量进行初始化，假如这个基类有很多个派生类，我们的这个代码就显得很冗余，而且这个派生类存在的意义就是减少这个雷同的成员变量的书写带来的贫苦，如许搞得话就不符合这个逻辑了；
（3）下面的就是我们定义了一个派生类和一个基类，通过初始化列表的方式，确定这个派生类调用的是基类里面的哪个构造函数；

1. class a
2. {
3. public:
4.         int m_a;
5. private:
6.         int m_b;
7. public:
8.         a()
9.                 :m_a(0)
10.                 , m_b(0)
11.         {
12.                 cout << "调用了基类的构造函数" << endl;
13.         }
14.         a(int aa, int bb)
15.                 :m_a(aa)
16.                 , m_b(bb)
17.         {
18.                 cout << "调用了含有两个参数的构造函数" << endl;
19.         }
20.         a(const a& aa)
21.                 :m_a(aa.m_a + 1)
22.                 , m_b(aa.m_b + 1)
23.         {
24.                 cout << "调用了基类的拷贝构造函数" << endl;
25.         }
26.         void showa()
27.         {
28.                 cout << "m_a数值大小：" << m_a << "m_b的数值大小" << m_b << endl;
29.         }
30. };
31. class b :public a
32. {
33. public:
34.         int m_c;
35.         b()
36.                 :m_c(0)
37.                 ,a()
38.         {
39.                 cout << "调用了这个派生类的构造函数" << endl;
40.         }
41.         b(int a, int b, int c)
42.                 :a(a, b)
43.                 , m_c(c)
44.         {
45.                 cout << "调用派生类的构造函数b(int a, int b, int c)" << endl;
46.         }
47.         b(const a& aa, int c)
48.                 :a(aa)
49.                 , m_c(c)
50.         {
51.                 cout << "调用派生类的拷贝构造函数" << endl;
52.         }
53.         void showb()
54.         {
55.                 cout << "m_c数值大小：" << m_c << endl;
56.         }
57. };
58. int main()
59. {
60.         b b1;
61.         b1.showa();
62.         b1.showb();
63.         cout << endl;
65.         b b2(1, 2, 3);
66.         b2.showa();
67.         b2.showb();
68.         cout << endl;
70.         a a1(10, 20);
71.         b b11(a1, 30);
72.         return 0;
73. }

复制代码

我们分别使用初始化列表的方式指定了调用默认的构造函数，调用含有多个参数的构造函数，以及这个拷贝构造函数；子类里面的第二个初始化列表我们使用的是这个基类的含有两个参数的构造函数进行初始化的，第三个初始化列表是使用基类里面的拷贝构造函数进行初始化的；
6.名字掩藏和类作用域

（1）下面就是定义了一个基类和一个子类，我们创建了一个子类的对象，这个基类和子类的这个成员变量的名字以及这个成员函数的名字都是一样的，这个时候我们的打印效果就是基类的成员变量和成员函数；

1. using namespace std;
2. class a
3. {
4. public:
5.         int m_a = 20;
6.         void show()
7.         {
8.                 cout << "调用了基类的函数" << endl;
9.         }
10. };
11. class b :public a
12. {
13. public:
14.         int m_a = 30;
15.         void show()
16.         {
17.                 cout << "调用了派生类的函数" << endl;
18.         }
19. };
20. int main()
21. {
22.         b b1;
23.         cout << "b1对象的m_a的值是：" << b1.m_a << endl;
24.         b1.show();
25.         return 0;
26. }

复制代码

（2）当基类的函数名和这个派生类里面的函数名字雷同的时候，因为这个是继续，以是派生类里面就会隐含的包罗了这个基类的成员变量和成员函数，名字雷同的时候，派生类的函数就会把这个基类里面函数覆盖掉；

1. using namespace std;
2. class a
3. {
4. public:
5.         int m_a = 20;
6.         void show()
7.         {
8.                 cout << "调用了基类的函数" << endl;
9.         }
10.         void func(int a)
11.         {
12.                 cout << "调用了这个函数" << endl;
13.         }
14. };
15. class b :public a
16. {
17. public:
18.         int m_a = 30;
19.         //void func() { cout << "调用了派生类的函数" << endl; }
20. };
21. int main()
22. {
23.         b b1;
24.         cout << "b1对象的m_a的值是：" << b1.m_a << endl;
25.         b1.show();
26.         b1.func(1);
27. }

复制代码

例如上面的这个步伐，两个雷同的函数func，假如我们把这个继续类里面的func函数放开，这个时候运行就会报错，因为这个时候父类的func函数会被覆盖掉，我们通报参数是不合语法的，但是我们把这个注释掉之后，就可以运行乐成，因为这个时候，不存在函数名字雷同的情况，我们就可以直接调用这个子类里面的有一个参数的func函数了，现实上这个成员函数在子类里面也是存在的，只要不重名，这个基类里面的这个函数就不会被覆盖掉；
现实上这个名字掩藏就是一个表象，类作用域才是实质，因为现实被骗存在继续关系的时候，这个基类的作用域是嵌套在这个派生类里面的，我们一般会在这个派生类里面去寻找，只有这个在派生类里面找不到的时候，才回到基类里面去寻找；
7.类继续的特殊关系

（1）假如我们使用派生类的对象赋值给基类的对象（包罗私有成员），但是这个时候会舍弃掉非基类成员：
下面这个代码里面，我们对于这个b1对象进行操作，最后把他赋值给a1这个对象，这个时候我们会发现a1这个对象里面的私有成员m_b也会被更新的，也就是说纵然是私有的成员变量，也是会被赋值的；

1. class a
2. {
3. public:
4.         int m_a = 0;
5. private:
6.         int m_b = 0;
7. public:
8.         void show()
9.         {
10.                 cout << "m_a:" << m_a << "   m_b:" << m_b << endl;
11.         }
12.         void setb(int b)
13.         {
14.                 m_b = b;
15.         }
16. };
17. class b :public a
18. {
19. public:
20.         int m_c = 0;
21.         void show()
22.         {
23.                 cout << "m_a:" << m_a << "   m_c:" << m_c << endl;
24.         }
25. };
26. int main()
27. {
28.         a a1;
29.         b b1;
30.         b1.m_a = 10;
31.         b1.setb(20);
32.         b1.m_c = 30;
34.         a1.show();
35.         a1 = b1;
36.         a1.show();
38.         return 0;
39. }

复制代码

（2）基类的指针可以不经过表现转换指向派生类的对象，因为基类和派生类有特殊的关系，他们的内存模型是一样的，以是使用基类的指针执行派生类，没有题目；
照旧上面得继续关系，我们定义基类的指针指向派生类的对象：

1. int main()
2. {
3.         b b1;
4.         a* a1 = &b1;
5.         b1.m_a = 10;
6.         b1.setb(20);
7.         b1.m_c = 30;
8.         b1.show();
9.         a1->m_a = 10;
10.         a1->setb(20);
11.         a1->show();
12.         return 0;
13. }

复制代码

8.多态和虚函数

（1）什么是多态？
多态就是我们定义了两个类之间的继续关系，定义了基类的指针pa,指向的是派生类的对象g,这个时候我们使用这个指针去调用函数，就只能调用基类的构造函数，因为这个指针就是基类的；
我们在这个基类的成员函数show前面加上virtual关键字，就可以使用这个执行派生类对象的指针去访问这个派生类的函数，纵然这个类是基类的，我们也是可以访问到这个派生类的成员函数的；
因为这个是函数前面加上virtual关键字，我们把这个函数叫做虚函数，有了虚函数之后，基类的指针指向基类对象就会调用基类的成员变量和函数，指向派生类的对象之后就会调用派生类的成员变量和函数，基类的指针表现出来多种形态，我们把这个现象叫做多态；

1. class allcomer
2. {
3. public:
4.         int m_bh;
5.         void show()
6.         {
7.                 cout << "class allcomer我的编号是：" << m_bh << endl;
8.         }
9. };
10. class cgril :public allcomer
11. {
12. public:
13.         int m_age;
14.         void show()
15.         {
16.                 cout << "class cgril :public allcomer我的年龄是" << m_age << endl;
17.         }
18. };
19. int main()
20. {
21.         cgril g;
22.         g.m_bh = 8;
23.         g.m_age = 18;
24.         g.show();
25.         allcomer* pa = &g;
26.         pa->show();
27.         return 0;
28. }

复制代码

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。