学习预览

学习共分为三个阶段：

  • 第一阶段：C++基础语法入门，对C++有初步了解，能够有几处编程能力
  • 第二阶段：C++核心编程，介绍C++面向对象编程，为大型项目做铺垫
  • 第三阶段：C++提高编程，介绍C++泛型编程思想，以及STL的基本使用

    C++基础

    程序流程结构

    选择结构

    if

    循环结构

    while
    do-while
    for

    跳转结构

    break：退出循环
    continue：结束本次循环，进入下次循环
    goto（不建议用）

    数组

    一维数组

    1、数组类型 数组名 [数组长度]；
    2、数组类型 数组名 [数组长度]={值1，值2……}
    3、数组类型 数组名[]={值1，值2，……}
    一维数组名称用途：
    sizeof(arr)：数组占用的内存空间
    (int)arr，(int)&arr[2]：数组首地址,每个元素的首地址
    冒泡排序法
    1、求最大值：

2、数组按大小逆置：

3、冒泡排序算法：

  1. #include<iostream>//头文件
  2. #include<string>
  3. using namespace std;
  5. int main()
  6. {
  7.     //1、创建数组
  8.     int arr[10] = { 7,8,6,3,2,5,0,1,4,9};
  9.     cout << "冒泡前： " << endl;
  10.     for (int i = 0; i < 10; i++)
  11.     {
  12.         cout << arr[i] << "  ";
  13.     }
  14.     cout << endl;
  15.     //2、排序
  16.     for (int i = 0; i < 10; i++)
  17.     {
  18.         for (int j = 0; j < 10 - i - 1; j++)
  19.         {
  20.             if (arr[j] > arr[j+1])
  21.             {
  22.                 //数字交换
  23.                 int temp = arr[j];
  24.                 arr[j] = arr[j + 1];
  25.                 arr[j + 1] = temp;
  26.             }
  27.         }
  28.     }
  29.     //3、打印
  30.     cout << "冒泡后： " << endl;
  31.     for (int i = 0; i < 10; i++)
  32.     {
  33.         cout << arr[i] << "  ";
  34.     }
  35. }

二维数组

二维数组定义
4种定义方法
二维数组名
1）可以查看占用内存大小；2）可以查看二维数组的首地址
image.png

函数

函数定义

1）返回值类型：一个函数名可以返回一个值，在函数中定义
2）函数名：给函数其名称；
3）参数列表：使用该函数时，传入的数据；
4）函数体语句：花括号内的代码，函数内需要执行的语句；
5）return表达式：和返回值类型挂钩，函数执行后，返回相应数据；
语法：
返回值类型 函数名 参数列表
{
函数体语句
return表达式
}

  1. int add(int a,int b)
  2. {
  3.     int C = a + b;
  4.     return C
  5. }

函数调用

语法： 函数名（参数列表）

值传递

实际参数和形式参数

函数常见样式

1）无参无返：void test()
2）有参无返：void test(参数列表)
3）无参有返：int test()
4）有参有返：int test(参数列表)

函数声明

提前通知函数的存在

函数的分文件编写

1、创建后缀名为.h的头文件

  1. #pragma once
  2. #include<iostream>
  3. using namespace std;
  4. void swap(int num1, int num2);
  5. int add(int num1, int num2);

2、创建.cpp后缀名的源文件

  1. #include"head.h";
  2. int add(int num1, int num2)
  3. {
  4.     int sum = num1 + num2;
  5.     return sum;
  6. }
  1. #include"head.h";
  2. void swap(int num1, int num2)
  3. {
  4.     int temp = num1;
  5.     num1 = num2;
  6.     num2 = temp;
  7.     cout << "a的值为：" << num1 << endl;
  8.     cout << "b的值为：" << num2<< endl;
  9. }

3、在头文件中写函数的声明
image.png
4、在源文件(main函数和被调函数)中写函数定义
image.png

  1. #include<iostream> //头文件
  2. #include<string>
  3. using namespace std;
  4. #include"head.h";//自定义的头文件
  6. int main()
  7. {
  8.     int a = 10;
  9.     int b = 20;
  10.     swap(a, b);
  11.     int c = add(a, b);
  12.     cout << "和为：" << c << endl;
  14. }

指针

指针定义

语法：数据类型 * 指针变量

  1. #include<iostream> //头文件
  2. #include<string>
  3. using namespace std;
  5. int main()
  6. {
  7.     int a = 10;
  8.     int* p;
  9.     p = &a;
  10.     cout << "p的值为：" << p << endl;
  11.     cout << "*p的值：" << *p << endl;
  12. }

指针占用空间大小

32位操作系统占用4字节；64位操作系统占用8字节

空指针

1）用以给指针变量进行初始化；2）空指针不可以进行访问。
int * p = NULL

野指针

指向非法空间
空指针和野指针不是我们能访问的空间

const修饰指针

const in p=&a（修饰指针指向的值）
int const p=&b（修饰指针指向）
const int * const p = &a（修饰指针指向和指针指向的值）

指针和数组

利用指针访问数组中元素

  1. #include<iostream> //头文件
  2. #include<string>
  3. using namespace std;
  4. #include"head.h";//自定义的头文件
  6. int main()
  7. {
  8.     //指针和数组
  9.     //利用指针访问数组中元素
  10.     int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
  11.     cout << "第一个元素位： " << arr[0] << endl;
  12.     int* p = arr;
  13.     cout << "指针指向元素为： " << *p << endl;
  14.     p++;
  15.     cout << "指针指向元素为： " << *p << endl;
  16.     cout << "利用指针遍历数组 " << endl;
  17.     int* p2 = arr;
  18.     for (int i = 0; i < 10; i++)
  19.     {
  20.         cout << *p2 << endl;
  21.         p2++;
  22.     }
  23. }

指针和函数

使用地址传递：可以修改实参的值；
值传递：不可以修改实参的值。

  1. #include<iostream> //头文件
  2. #include<string>
  3. using namespace std;
  4. #include"head.h";//自定义的头文件
  6. void swap02(int* p1, int* p2)
  7. {
  8.     int temp = *p1;
  9.     *p1 = *p2;
  10.     *p2 = temp;
  11. }
  13. int main()
  14. {
  15.     //指针和函数
  16.     //
  17.     int a = 10;
  18.     int b = 20;
  19.     swap02(&a, &b);
  20.     cout << "a=" << a << endl;
  21.     cout << "b=" << b << endl;
  22. }

指针、数组与函数的应用案例

案例描述：封装一个函数，利用冒泡排序，实现对整型数组的升序排序

  1. #include<iostream> //头文件
  2. #include<string>
  3. using namespace std;
  4. #include"head.h";//自定义的头文件
  5. //冒泡排序函数
  6. void bubbsort(int* arr, int len)
  7. {
  8.     for (int i = 0; i < len - 1; i++)
  9.     {
  10.         for (int j = 0; j < len - i - 1; j++)
  11.         {
  12.             if (arr[j] > arr[j + 1])
  13.             {
  14.                 int temp = arr[j];
  15.                 arr[j] = arr[j + 1];
  16.                 arr[j + 1] = temp;
  17.             }
  18.         }
  19.     }
  20. }
  21. void printArr(int* arr, int len)
  22. {
  23.     for (int i = 0; i < len;i++)
  24.     {
  25.         cout << arr[i]<<"  ";
  26.     }
  27.     cout << endl;
  28. }
  30. int main()
  31. {
  32.     //1、先创建一个数组
  33.     int arr[10] = {4,3,6,9,1,2,10,8,7,5};
  34.     int len = sizeof(arr) / sizeof(arr[0]);
  35.     cout << "原数组为： " << endl;
  36.     printArr(arr, len);
  37.     //2、创建函数，实现冒泡排序
  38.     bubbsort(arr, len);
  39.     //3、打印排序后的数组
  40.     cout << "排序后为： " << endl;
  41.     printArr(arr, len);
  42.     system("pause");
  43.     return 0;
  44. }

结构体

结构体的定义和使用

结构体属于用户自定义的数据类型，允许用户存储不同的数据类型
创建方法：

  • struct 结构体名 变量名
  • struct 结构体名 变量名={成员数值1，成员数组2…..}
  • 在定义结构体时顺便创建结构体变量

image.png

  1. #include<iostream> //头文件
  2. #include<string>
  3. using namespace std;
  4. #include"head.h";//自定义的头文件
  6. //1、创建学生数据类型 ：学生包括（姓名。年龄，分数）
  7. //自定义数据类型，一些类型集合组成的一个类型
  8. //语法  struct 类型名
  9. //结构体定义
  10. struct Student
  11. {
  12.     //成员列表
  14.     //姓名
  15.     string name;
  16.     //年龄
  17.     int age;
  18.     //分数
  19.     int score;
  20. }s3;
  21. int main()
  22. {
  23.     //2、通过学生类型创建具体学生（三种方式）
  24.     // 创建结构体变量时，Struct可以省略
  25.     //2.1、struct Student s1
  26.     Student s1;
  27.     s1.name = "张三";
  28.     s1.age = 18;
  29.     s1.score = 100;
  30.     cout << "姓名： " << s1.name << "  年龄： " << s1.age << "  分数： " << s1.score << endl;
  31.     //2.2、struct Student s2={...}
  32.     struct Student s2 = { "李四",19,80 };
  33.     cout << "姓名： " << s2.name << "  年龄： " << s2.age << "  分数： " << s2.score << endl;
  35.     //2.3、在定义结构体时顺便创建结构变量（不建议使用）
  36.     s3.name = "王五";
  37.     s3.age = 20;
  38.     s3.score = 60;
  39.     cout << "姓名： " << s3.name << "  年龄： " << s3.age << "  分数： " << s3.score << endl;
  40. }

结构体数组

作用：将自定义的结构体放入到数组中，方便维护
语法：struct 结构体名 数组名[元素数目]={…………..}

  1. #include<iostream> //头文件
  2. #include<string>
  3. using namespace std;
  4. #include"head.h";//自定义的头文件
  6. //结构体数组
  7. //1、定义结构体
  8. struct Student
  9. {
  10.     string name;
  11.     int age;
  12.     int score;
  13. };
  15. int main()
  16. {
  17.     //2、创建结构体数组
  18.     struct Student stuArray[3] =
  19.     {
  20.         {"张三",18,100},
  21.         {"李四",28,99},
  22.         {"王五",38,66}
  23.     };
  24.     //3、给结构体数组中的元素赋值、
  25.     stuArray[2].name = "赵六";
  26.     stuArray[2].age = 80;
  27.     stuArray[2].score = 60;
  28.     //4、遍历结构体数组
  29.     for (int i = 0; i < 3; i++)
  30.     {
  31.         cout << "  姓名为：" << stuArray[i].name << "  年龄为： " << stuArray[i].age << "  分数为： " << stuArray[i].score << endl;
  32.     }
  33. }

结构体指针

作用：利用结构体指针访问结构体中的成员

  1. #include<iostream> //头文件
  2. #include<string>
  3. using namespace std;
  5. //结构体指针
  6. //1、定义结构体
  7. struct Student
  8. {
  9.     string name;
  10.     int age;
  11.     int score;
  12. };
  14. int main()
  15. {
  16.     //1、创建学生结构体变量
  17.     struct Student s = { "张三",18,100};
  18.     //2、通过指针指向结构体变量
  19.     struct Student * p = &s;
  20.     //3、通过指针访问结构体变量中的数据
  21.     cout << "姓名： " << p->name << "  年龄： " << p->age << "  分数： " << p->score << endl;
  22. }

结构体嵌套结构结构体

作用：结构体中的成员可以是另一个结构体

  1. #include<iostream> //头文件
  2. #include<string>
  3. using namespace std;
  5. //结构体嵌套结构体
  6. // 1、定义学生结构体
  7. struct student
  8. {
  9.     string name;
  10.     int age;
  11.     int score;
  12. };
  13. //2、定义老师结构体
  14. struct teacher
  15. {
  16.     int id;
  17.     string name;
  18.     int age;
  19.     struct student stu;
  20. };
  22. int main()
  23. {
  24.     //3、创建老师结构体变量
  25.     struct teacher t;
  26.     t.id = 10000;
  27.     t.name = "老王";
  28.     t.age = 50;
  29.     t.stu.name = "小王";
  30.     t.stu.age = 20;
  31.     t.stu.score = 60;
  32.     cout << "老师姓名：" << t.name << "  老师编号： " << t.id << "  老师年龄：" << t.age
  33.         << "  学生姓名： " << t.stu.name << "  学生年龄： " << t.stu.age << "  学生成绩： " << t.stu.score << endl;
  34. }

结构体做函数参数

作用：接昂结构体作为参数向函数中传递
传递的两种方式：

  • 值传递（形参改变，实参不会改变）
  • 地址传递（形参改变，实参也会改变） ```cpp

    include //头文件

    include

    using namespace std;

//结构体嵌套结构体 // 1、定义学生结构体 struct Student { string name; int age; int score; };

//打印学生信息 //1、值传递 void printStudent(struct Student s) { cout << “姓名：” << s.name << “ 年龄： “ << s.age << “ 成绩： “ << s.score << endl; } //2、地址传递 //将形参改为指针，可以减少内存，而且不会复制新的副本 void printStudent(struct Student* p) { cout << “姓名：” << p->name << “ 年龄：” << p->age << “ 成绩：” << p->score << endl; } int main() { //结构体做函数参数 //创建结构体变量 struct Student s1; s1.name = “张三”; s1.age = 18; s1.score = 80;

  1. struct Student s2;
  2. s2.name = "李四";
  3. s2.age = 20;
  4. s2.score = 90;
  6. printStudent(s1);
  7. printStudent(&s2);

}

  1. <a name="mrTXp"></a>
  2. #### 结构体中Const的使用场景
  3. 作用：用const来防止误操作
  4. ```cpp
  5. #include<iostream> //头文件
  6. #include<string>
  7. using namespace std;
  9. //结构体嵌套结构体
  10. // 1、定义学生结构体
  11. struct Student
  12. {
  13.     string name;
  14.     int age;
  15.     int score;
  16. };
  18. //打印学生信息
  19. //1、值传递
  20. void printStudent(struct Student s)
  21. {
  22.     cout << "姓名：" << s.name << "  年龄： " << s.age << "  成绩： " << s.score << endl;
  23. }
  24. //2、地址传递
  25. void printStudent(const struct Student* p)  //加入const后，一旦修改，就会报错
  26. {
  27.     cout << "姓名：" << p->name << "  年龄：" << p->age << "  成绩：" << p->score << endl;
  28. }
  29. int main()
  30. {
  31.     //结构体做函数参数
  32.     //创建结构体变量
  33.     struct Student s1;
  34.     s1.name = "张三";
  35.     s1.age = 18;
  36.     s1.score = 80;
  38.     struct Student s2;
  39.     s2.name = "李四";
  40.     s2.age = 20;
  41.     s2.score = 90;
  43.     printStudent(s1);
  44.     printStudent(&s2);
  45. }

结构体实践

案例1：
image.png

  1. #include<iostream> //头文件
  2. #include<string>
  3. #include<ctime>
  4. using namespace std;
  6. //案列1
  7. // 定义学生结构体
  8. struct Student
  9. {
  10.     string sname;
  11.     int score;
  12. };
  14. // 定义老师结构体
  15. struct teacher
  16. {
  17.     string tname;
  18.     struct Student sArray[5];
  19. };
  20. //给老师和学生赋值的函数
  21. void allocatespace(struct teacher tArray[],int len)
  22. {
  23.     string nameseed = "ABCDE";
  24.     for (int i = 0;i < len;i++)
  25.     {
  26.         tArray[i].tname = "teacher_";
  27.         tArray[i].tname += nameseed[i];
  28.         //通过循环给每名老师带的学生赋值
  29.         for (int j = 0; j < 5; j++)
  30.         {
  31.             tArray[i].sArray[j].sname = "Student";
  32.             tArray[i].sArray[j].sname += nameseed[j];//字符串拼接
  33.             int random = rand() % 61 + 40; //使用随机数定义[40,100]的分数区间
  34.             tArray[i].sArray[j].score = random;
  35.         }
  36.     }
  37. }
  39. void printInfo(struct teacher tArray[],int len)
  40. {
  41.     for (int i = 0; i < len; i++)
  42.     {
  43.         cout << "老师姓名：" << tArray[i].tname << endl;
  44.         for (int j = 0;j < 5;j++)
  45.         {
  46.             cout << "\t学生姓名：" << tArray[i].sArray[j].sname <<"  "<<
  47.                 "考试分数：" << tArray[i].sArray[j].score << endl;
  48.         }
  49.     }
  50. }
  52. int main()
  53. {
  54.     //随机种子(作用是使分数更加随机？)
  55.     srand((unsigned int)time(NULL));
  57.     //1、创建3名老师的数组
  58.     struct teacher tArray[3];
  60.     //2、通过函数给3名老师的信息赋值，并给老师带的学生信息赋值；
  61.     int len = sizeof(tArray) / sizeof(tArray[0]);
  62.     allocatespace(tArray, len);
  64.     //3、打印所有老师及所带学生信息
  65.     printInfo(tArray, len);
  66. }

案例2：
image.png

  1. #include<iostream> //头文件
  2. #include<string>
  3. using namespace std;
  5. //案列2
  6. //1、创建英雄数组
  7. struct Hero 
  8. {
  9.     string name;
  10.     int age;
  11.     string sex;
  12. };
  13. //冒泡排序
  14. void bubbleSort(struct Hero heroArray[],int len) 
  15. {
  16.     for (int i = 0;i < len - 1;i++)
  17.         for (int j = 0; j < len - i - 1; j++)
  18.         {
  19.             if (heroArray[j].age > heroArray[j + 1].age)
  20.             {
  21.                 struct Hero temp = heroArray[j];
  22.                 heroArray[j] = heroArray[j + 1];
  23.                 heroArray[j + 1] = temp;
  24.             }
  25.         }
  26. }
  27. //打印程序
  28. void printHero(struct Hero heroArray[], int len)
  29. {
  30.     for (int i = 0; i < len; i++)
  31.     {
  32.         cout << "姓名： " << heroArray[i].name << "  年龄：" << heroArray[i].age 
  33.             << "  性别：" << heroArray[i].sex<< endl;
  34.     }
  35. }
  37. int main()
  38. {
  39.     //2、创建数组存放5名英雄
  40.     struct Hero heroArray[5] = 
  41.     {
  42.         {"刘备",23,"男"},
  43.         {"关羽",22,"男"},
  44.         {"张飞",20,"男"},
  45.         {"赵云",21,"男"},
  46.         {"貂蝉",19,"女"}
  47.     };
  48.     int len = sizeof(heroArray) / sizeof(heroArray[0]);
  49.     //3、对数组排序，按照年龄顺序
  50.     bubbleSort(heroArray, len);
  51.     //4、打印输出
  52.     printHero(heroArray, len);
  53. }

项目开发实战

通讯录管理系统

1、退出系统
2、添加联系人
image.png

  1. void addPerson(Addressbooks * abs)
  2. {
  3.     //判断通讯是否已满，如满就不添加
  4.     if (abs->m_Size > MAX)
  5.     {
  6.         cout << "通讯录已满，无法添加！" << endl;
  7.         return;
  8.     }
  9.     else
  10.     {
  11.         //添加具体联系人
  13.         //姓名
  14.         string name;
  15.         cout << "请输入姓名：" << endl;
  16.         cin >> name;
  17.         abs->personArray[abs->m_Size].m_Name = name;
  18.         //性别
  19.         cout << "请输入性别：" << endl;
  20.         cout << "1---男" << endl;
  21.         cout << "2---女" << endl;
  22.         int sex = 0;
  23.         while (true)
  24.         {
  25.             cin >> sex;
  26.             if (sex == 1 || sex == 2)
  27.             {
  28.                 //如果输入1或2，可以退出循环，如果不是，重新输入
  29.                 abs->personArray[abs->m_Size].m_Sex = sex;
  30.                 break;
  31.             }
  32.             cout << "输入有误，清重新输入！" << endl;
  33.         }
  35.         //年龄
  36.         cout << "请输入年龄：" << endl;
  37.         int age = 0;
  38.         cin >> age;
  39.         abs->personArray[abs->m_Size].m_Age = age;
  40.         //电话
  41.         cout << "请输入联系电话：" << endl;
  42.         string phone;
  43.         cin >> phone;
  44.         abs->personArray[abs->m_Size].m_Phone = phone;
  45.         //住址
  46.         cout << "请输入家庭住址：" << endl;
  47.         string address;
  48.         cin >> address;
  49.         abs->personArray[abs->m_Size].m_Addr = address;
  51.         //更新通讯录人数
  52.         abs->m_Size++;
  53.         cout << "添加成功！" << endl;
  54.         system("pause"); //请按任意键继续
  55.         system("cls");   //清屏操作
  56.     }
  57. }

3、显示联系人
image.png
封装显示联系人的思路：
PS:1）三目运算符的使用；2）转置运算符”\t”

  1. void showPerson(Addressbooks* abs)
  2. {
  3.     //判断通讯录中人数是否为0，提示记录为空
  4.     //如果不是0，显示记录的联系人信息
  5.     if (abs->m_Size == 0)
  6.     {
  7.         cout << "当前记录为空" << endl;
  9.     }
  10.     else
  11.     {
  12.         for (int i = 0; i < abs->m_Size; i++)
  13.         {
  14.             cout << "姓名： " <<abs->personArray[i].m_Name<<"\t";
  15.             cout << "性别： " <<(abs->personArray[i].m_Sex == 1?"男":"女") << "\t";  //使用三目运算符简化代码
  16.             cout << "年龄： " << abs->personArray[i].m_Age << "\t";
  17.             cout << "电话： " << abs->personArray[i].m_Phone << "\t";
  18.             cout << "住址： " << abs->personArray[i].m_Addr << endl;
  19.         }
  20.     }
  21.     system("pause");
  22.     system("cls");
  23. }

4、删除联系人
image.png

  1. //检测联系人是否存在（如果存在，返回联系人具体位置，不存在返回-1）
  2. //参数1  通讯录，  参数2  对比姓名
  3. int isExist(Addressbooks* abs, string name)
  4. {
  5.     for (int i = 0; i < abs->m_Size; i++)
  6.     {
  7.         //
  8.         if (abs->personArray[i].m_Name == name)
  9.         {
  10.             return i;
  11.         }
  12.         else
  13.         {
  14.             return -1;
  15.         }
  16.     }
  17. }
  1. //删除联系人
  2. void deletePerson(Addressbooks* abs)
  3. {
  4.     cout << "请输入要删除人员姓名：" << endl;
  5.     string name;
  6.     cin >> name;
  8.     //ret  =-1 未查到
  9.     //ret !=-1  查到
  10.     int ret = isExist(abs, name);
  11.     if (ret != -1)
  12.     {
  13.         //查到此人，要进行删除操作
  14.         for (int i = ret; i < abs->m_Size; i++)
  15.         {
  16.             //数据前移
  17.             abs->personArray[i] = abs->personArray[i + 1];
  18.         }
  19.         abs->m_Size--;//更新通讯录中的人员数
  20.         cout << "删除成功" << endl;
  21.     }
  22.     else
  23.     {
  24.         cout << "查无此人" << endl;
  25.     }
  26.     system("pause");
  27.     system("cls");
  28. }

5、查找联系人
image.png

  1. //查找联系人
  2. void findPerson(Addressbooks* abs)
  3. {
  4.     cout << "请输入要查找的联系人：" << endl;
  5.     string name;
  6.     cin >> name;
  8.     //判断指定联系人是否在通讯录中
  9.     int ret = isExist(abs, name);
  10.     if (ret != -1)  //找到联系人
  11.     {
  12.         cout << "姓名：" << abs->personArray[ret].m_Name << endl;
  13.         cout << "性别：" << abs->personArray[ret].m_Sex << endl;
  14.         cout << "年龄：" << abs->personArray[ret].m_Age << endl;
  15.         cout << "电话：" << abs->personArray[ret].m_Phone << endl;
  16.         cout << "住址：" << abs->personArray[ret].m_Sex << endl;
  17.     }
  18.     else //未找到联系人
  19.     {
  20.         cout << "查无此人" << endl;
  21.     }
  22.     //按任意键清屏
  23.     system("pause");
  24.     system("cls");
  25. }

5、修改联系人
image.png

  1. //修改联系人
  2. void modifyPerson(Addressbooks* abs)
  3. {
  4.     cout << "请输入要修改人的姓名：" << endl;
  5.     string name;
  6.     cin >> name;
  8.     int ret = isExist(abs, name);
  10.     if (ret != -1)
  11.     {
  12.         //姓名
  13.         string name;
  14.         cout << "请输入姓名：" << endl;
  15.         cin >> name;
  16.         abs->personArray[ret].m_Name = name;
  18.         //性别
  19.         cout << "请输入性别：" << endl;
  20.         cout << "1---男" << endl;
  21.         cout << "2---女" << endl;
  22.         int sex = 0;
  23.         while (true)
  24.         {
  25.             cin >> sex;
  26.             if (sex == 1 || sex == 2)
  27.             {
  28.                 //输入正确，退出循环输入
  29.                 abs->personArray[ret].m_Sex = sex;
  30.                 break;
  31.             }
  32.             else
  33.             {
  34.                 cout << "输入有误，请重新输入！" << endl;
  35.             }
  36.         }
  38.         //年龄
  39.         int age;
  40.         cout << "请输入年龄：" << endl;
  41.         cin >> age;
  42.         abs->personArray[ret].m_Age = age;
  43.         //联系电话
  44.         string phone;
  45.         cout << "请输入联系方式：" << endl;
  46.         cin >> phone;
  47.         abs->personArray[ret].m_Phone = phone;
  49.         //住址
  50.         cout << "请输入家庭住址：" << endl;
  51.         string address;
  52.         cin >> address;
  53.         abs->personArray[ret].m_Addr = address;
  55.         cout << "已修改成功！" << endl;
  56.     }
  57.     else
  58.     {
  59.         cout << "查无此人" << endl;
  60.     }
  61.     system("pause");   //按任意键继续
  62.     system("cls");     //修改完成后清屏
  63. }

6、清空联系人
image.png

  1. //清空联系人
  2. void cleanPerson(Addressbooks* abs)
  3. {
  4.     abs->m_Size = 0;     //将当期记录联系人数量置0，做逻辑清空操作
  5.     cout << "通讯录已清空！" << endl;
  6.     system("pause");
  7.     system("cls");
  8. }

全部程序

  2. //-封装函数显示该界面 如void showMenu()
  3. //-在main函数中调用封装好的函数
  4. #include <iostream>
  5. #include <string>
  6. #define MAX 1000   //宏定义数目
  8. using namespace std;
  10. //菜单界面
  11. void showMenu()
  12. {
  13.     cout << "**********************" << endl;
  14.     cout << "*****1、添加联系人*****" << endl;
  15.     cout << "*****2、显示联系人*****" << endl;
  16.     cout << "*****3、删除联系人*****" << endl;
  17.     cout << "*****4、查找联系人*****" << endl;
  18.     cout << "*****5、修改联系人*****" << endl;
  19.     cout << "*****6、清空联系人*****" << endl;
  20.     cout << "*****0、退出通讯录*****" << endl;
  21.     cout << "**********************" << endl;
  22. }
  24. //设计联系人结构体
  25. struct person
  26. {
  27.     string m_Name;   //姓名
  28.     int m_Sex;       //性别：1、男 2、女 
  29.     int m_Age;       //年龄
  30.     string m_Phone;  //电话
  31.     string m_Addr;   //住址
  33. };
  35. //设计通讯录结构体
  36. struct Addressbooks 
  37. {
  38.     struct person personArray[MAX];  //通讯录中保存的联系人数组
  39.     int m_Size;                     //通讯录中当前记录联系人个数
  40. };
  42. //1、添加联系人
  43. void addPerson(Addressbooks * abs)
  44. {
  45.     //判断通讯是否已满，如满就不添加
  46.     if (abs->m_Size > MAX)
  47.     {
  48.         cout << "通讯录已满，无法添加！" << endl;
  49.         return;
  50.     }
  51.     else
  52.     {
  53.         //添加具体联系人
  55.         //姓名
  56.         string name;
  57.         cout << "请输入姓名：" << endl;
  58.         cin >> name;
  59.         abs->personArray[abs->m_Size].m_Name = name;
  60.         //性别
  61.         cout << "请输入性别：" << endl;
  62.         cout << "1---男" << endl;
  63.         cout << "2---女" << endl;
  64.         int sex = 0;
  65.         while (true)
  66.         {
  67.             cin >> sex;
  68.             if (sex == 1 || sex == 2)
  69.             {
  70.                 //如果输入1或2，可以退出循环，如果不是，重新输入
  71.                 abs->personArray[abs->m_Size].m_Sex = sex;
  72.                 break;
  73.             }
  74.             cout << "输入有误，清重新输入！" << endl;
  75.         }
  77.         //年龄
  78.         cout << "请输入年龄：" << endl;
  79.         int age = 0;
  80.         cin >> age;
  81.         abs->personArray[abs->m_Size].m_Age = age;
  82.         //电话
  83.         cout << "请输入联系电话：" << endl;
  84.         string phone;
  85.         cin >> phone;
  86.         abs->personArray[abs->m_Size].m_Phone = phone;
  87.         //住址
  88.         cout << "请输入家庭住址：" << endl;
  89.         string address;
  90.         cin >> address;
  91.         abs->personArray[abs->m_Size].m_Addr = address;
  93.         //更新通讯录人数
  94.         abs->m_Size++;
  95.         cout << "添加成功！" << endl;
  96.         system("pause"); //请按任意键继续
  97.         system("cls");   //清屏操作
  98.     }
  99. }
  101. //2、显示联系人
  102. void showPerson(Addressbooks* abs)
  103. {
  104.     //判断通讯录中人数是否为0，提示记录为空
  105.     //如果不是0，显示记录的联系人信息
  106.     if (abs->m_Size == 0)
  107.     {
  108.         cout << "当前记录为空" << endl;
  110.     }
  111.     else
  112.     {
  113.         for (int i = 0; i < abs->m_Size; i++)
  114.         {
  115.             cout << "姓名： " <<abs->personArray[i].m_Name<<"\t";
  116.             cout << "性别： " <<(abs->personArray[i].m_Sex == 1?"男":"女") << "\t";  //使用三目运算符简化代码
  117.             cout << "年龄： " << abs->personArray[i].m_Age << "\t";
  118.             cout << "电话： " << abs->personArray[i].m_Phone << "\t";
  119.             cout << "住址： " << abs->personArray[i].m_Addr << endl;
  120.         }
  121.     }
  122.     system("pause");
  123.     system("cls");
  124. }
  126. //检测联系人是否存在（如果存在，返回联系人具体位置，不存在返回-1）
  127. //参数1  通讯录，  参数2  对比姓名
  128. int isExist(Addressbooks* abs, string name)
  129. {
  130.     for (int i = 0; i < abs->m_Size; i++)
  131.     {
  132.         //
  133.         if (abs->personArray[i].m_Name == name)
  134.         {
  135.             return i;
  136.         }
  137.         else
  138.         {
  139.             return -1;
  140.         }
  141.     }
  142. }
  144. //删除联系人
  145. void deletePerson(Addressbooks* abs)
  146. {
  147.     cout << "请输入要删除人员姓名：" << endl;
  148.     string name;
  149.     cin >> name;
  151.     //ret  =-1 未查到
  152.     //ret !=-1  查到
  153.     int ret = isExist(abs, name);
  154.     if (ret != -1)
  155.     {
  156.         //查到此人，要进行删除操作
  157.         for (int i = ret; i < abs->m_Size; i++)
  158.         {
  159.             //数据前移
  160.             abs->personArray[i] = abs->personArray[i + 1];
  161.         }
  162.         abs->m_Size--;//更新通讯录中的人员数
  163.         cout << "删除成功" << endl;
  164.     }
  165.     else
  166.     {
  167.         cout << "查无此人" << endl;
  168.     }
  169.     system("pause");
  170.     system("cls");
  171. }
  173. //查找联系人
  174. void findPerson(Addressbooks* abs)
  175. {
  176.     cout << "请输入要查找的联系人：" << endl;
  177.     string name;
  178.     cin >> name;
  180.     //判断指定联系人是否在通讯录中
  181.     int ret = isExist(abs, name);
  182.     if (ret != -1)  //找到联系人
  183.     {
  184.         cout << "姓名：" << abs->personArray[ret].m_Name << endl;
  185.         cout << "性别：" << abs->personArray[ret].m_Sex << endl;
  186.         cout << "年龄：" << abs->personArray[ret].m_Age << endl;
  187.         cout << "电话：" << abs->personArray[ret].m_Phone << endl;
  188.         cout << "住址：" << abs->personArray[ret].m_Sex << endl;
  189.     }
  190.     else //未找到联系人
  191.     {
  192.         cout << "查无此人" << endl;
  193.     }
  194.     //按任意键清屏
  195.     system("pause");
  196.     system("cls");
  197. }
  199. //修改联系人
  200. void modifyPerson(Addressbooks* abs)
  201. {
  202.     cout << "请输入要修改人的姓名：" << endl;
  203.     string name;
  204.     cin >> name;
  206.     int ret = isExist(abs, name);
  208.     if (ret != -1)
  209.     {
  210.         //姓名
  211.         string name;
  212.         cout << "请输入姓名：" << endl;
  213.         cin >> name;
  214.         abs->personArray[ret].m_Name = name;
  216.         //性别
  217.         cout << "请输入性别：" << endl;
  218.         cout << "1---男" << endl;
  219.         cout << "2---女" << endl;
  220.         int sex = 0;
  221.         while (true)
  222.         {
  223.             cin >> sex;
  224.             if (sex == 1 || sex == 2)
  225.             {
  226.                 //输入正确，退出循环输入
  227.                 abs->personArray[ret].m_Sex = sex;
  228.                 break;
  229.             }
  230.             else
  231.             {
  232.                 cout << "输入有误，请重新输入！" << endl;
  233.             }
  234.         }
  236.         //年龄
  237.         int age;
  238.         cout << "请输入年龄：" << endl;
  239.         cin >> age;
  240.         abs->personArray[ret].m_Age = age;
  241.         //联系电话
  242.         string phone;
  243.         cout << "请输入联系方式：" << endl;
  244.         cin >> phone;
  245.         abs->personArray[ret].m_Phone = phone;
  247.         //住址
  248.         cout << "请输入家庭住址：" << endl;
  249.         string address;
  250.         cin >> address;
  251.         abs->personArray[ret].m_Addr = address;
  253.         cout << "已修改成功！" << endl;
  254.     }
  255.     else
  256.     {
  257.         cout << "查无此人" << endl;
  258.     }
  259.     system("pause");   //按任意键继续
  260.     system("cls");     //修改完成后清屏
  261. }
  263. //清空联系人
  264. void cleanPerson(Addressbooks* abs)
  265. {
  266.     abs->m_Size = 0;     //将当期记录联系人数量置0，做逻辑清空操作
  267.     cout << "通讯录已清空！" << endl;
  268.     system("pause");
  269.     system("cls");
  270. }
  271. int main()
  272. {
  273.     //创建通讯录结构体变量
  274.     Addressbooks abs;
  275.     //初始化
  276.     abs.m_Size = 0;
  277.     int select = 0;//创建用户选择输入的变量
  279.     while (true)
  280.     {
  281.         //菜单调用
  282.         showMenu();
  284.         cin >> select;
  286.         switch (select)
  287.         {
  288.         case 1:    //添加联系人
  289.             addPerson(&abs);
  290.             break;
  291.         case 2:    //显示联系人
  292.             showPerson(&abs);
  293.             break;
  294.         case 3:    //删除联系人
  295.             deletePerson(&abs);
  296.             break;
  297.         case 4:   //查找联系人
  298.             findPerson(&abs);
  299.             break;
  300.         case 5:   //修改联系人
  301.             modifyPerson(&abs);
  302.             break;
  303.         case 6:   //清空联系人
  304.             cleanPerson(&abs);
  305.             break;
  306.         case 0:   //退出通讯录
  307.             cout << "欢迎下次使用" << endl;
  308.             system("pause");   //按任意键继续
  309.             return 0;
  310.             break;
  311.         default:
  313.             break;
  314.         }
  315.     }
  316.     system("pause");  //请按任意键继续
  317.     return 0;
  318. }

C++核心编程

本阶段主要针对C++面向对象编程技术做详细讲解，探讨C++的核心和精髓

内存分区模型

四个区的划分：
image.png

  1. #include<iostream> //头文件
  2. #include<string>
  3. #include<ctime>
  4. using namespace std;
  6. //全局变量、静态变量、常量
  8. //全局变量
  9. int g_a = 10;
  10. int g_b = 10;
  12. //const修饰的全局变量
  13. const int c_g_a = 10;
  14. const int c_g_b = 10;
  16. int main()
  17. {
  18.     cout << "全局变量g_a的地址为：" << &g_a << endl;
  19.     cout << "全局变量g_b的地址为：" << &g_b << endl;
  21.     cout << "全局常量c_g_a的地址为：" << &c_g_a << endl;
  22.     cout << "全局常量c_g_b的地址为：" << &c_g_b << endl;
  24.     //静态变量 在普通变量前添加static
  25.     static int s_a = 10;
  26.     static int s_b = 10;
  27.     cout << "静态变量s_a的地址为：" << (int)&s_a << endl;
  28.     cout << "静态变量s_b的地址为：" << (int)&s_b << endl;
  30.     //创建普通局部变量
  31.     int l_a = 10;
  32.     int l_b = 10;
  33.     cout << "局部变量l_a的地址为：" << &l_a << endl;
  34.     cout << "局部变量l_b的地址为：" << &l_b << endl;
  36.     //创建局部常量
  37.     const int c_l_a = 10;
  38.     const int c_l_b = 10;
  39.     cout << "局部常量c_l_a的地址为：" << &c_l_a << endl;
  40.     cout << "局部常量c_l_b的地址为：" << &c_l_b << endl;
  43.     //常量
  44.     //字符串常量
  45.     cout << "字符串常量的地址为：" << (int)&"hello world" << endl;
  47.     //const修饰的全局变量，const修饰的局部变量    
  49.     system("pause");
  50.     return 0;
  51. }

程序运行前

在程序编译后，生成了exe可执行程序，未执行该程序前分为两个阶段
代码区：1）只读；2）共享
全局区：该区域的数据在程序结构后由操作系统释放
image.png

程序运行中

image.png
局部变量存放在栈区，函数运行完成，自动清理

  1. int * func()
  2. {
  3.     int a = 10;
  4.     return &a;   //返回局部变量地址，有误
  5. }
  6. int main()
  7. {
  8.     int * p = func();
  9.     cout<<*p<<endl;  //编译器保留一次局部变量数据
  10.     cout<<*p<<endl;  //编译器不会保存两次局部变量数据
  11.     system("pause");
  13.     return 0;
  14. }

image.png

  1. #include<iostream> //头文件
  2. #include<string>
  3. using namespace std;
  5. int func()
  6. {
  7.     //利用new关键字 可以将数据开辟到堆区
  8.     //指针本质也是局部变量，放在栈上
  9.     int* p = new int(10);
  10.     return p;
  11. }
  13. int main()
  14. {
  15.     //在堆区开辟数据
  17.     cout << *p << endl;
  18.     cout << *p << endl;
  20.     system("pause");
  21.     return 0;
  23. }

image.png

new操作符

  1. #include<iostream> //头文件
  2. #include<string>
  3. using namespace std;
  5. //1、new的基本语法
  6. int* func()
  7. {
  8.     //在堆区创建整型数据
  9.     //new返回使该整型类型的指针
  10.     int* p = new int(10);
  11.     return p;
  12. }
  14. //2、在堆区利用new开辟数组
  15. void test02()
  16. {
  17.     //创建
  18.     int* arr = new int[10];  //10代表数组由10各元素
  20.     for (int i = 0; i < 10; i++)
  21.     {
  22.         arr[i] = i + 100;
  23.     }
  24.     for (int i = 0; i < 10; i++)
  25.     {
  26.         cout << arr[i] << endl;
  27.     }
  28.     //释放堆区数组
  29.     //释放数组的时候，要加[]才行
  30. }
  32. int main()
  33. {
  34.     int* p = func();
  35.     cout << *p << endl;
  36.     cout << *p << endl;
  37.     test02();
  39.     system("pause");
  40.     return 0;
  41. }

引用

引用的基本使用

image.png

  1. #include<iostream> //头文件
  2. #include<string>
  3. using namespace std;
  5. int main()
  6. {
  7.     int a = 10;
  8.     int& b = a;  //变量a的别名为b
  10.     cout << "a=" << a << endl;
  11.     cout << "b=" << b << endl;
  13.     system("pause");
  14.     return 0;
  15. }

引用注意事项

  • 引用必须初始化（int &b;,错误）；
  • 引用之后就不可以改变（如果定义为a的别名，就不能设置为其他变量的别名）

    引用做函数参数

    作用：函数传参时，可以利用引用的技术让形参修饰实参
    优点：可以简化指针修改实参 ```cpp

    include //头文件

    include

    using namespace std;

//交换函数

//1、值传递 void myswap01(int a, int b) { int temp = a; a = b; b = temp; } //2、地址传递 void myswap02(int a, int b) { int temp = a; a = b; b = temp; }

//3、引用传递 void myswap03(int &a, int &b) { int temp = a; a = b; b = temp; }

int main() { int a = 10; int b = 20;
//myswap01(a,b); //值传递，形参无法修改实参 myswap02(&a, &b); //指针传递，形参可以修改实参 //myswap03(a,b); // 引用传递，形参可以修改实参

  1. cout << "a=" << a << endl;
  2. cout << "b=" << b << endl;
  4. system("pause");
  5. return 0;

}

  1. <a name="cGDci"></a>
  2. #### 引用做函数返回值
  3. ```cpp
  4. #include<iostream> //头文件
  5. #include<string>
  6. using namespace std;
  8. //函数做函数返回值
  9. //1、不要返回局部变量的引用
  10. //2、函数的调用可以作为左值
  12. //返回局部变量引用
  13. int& test01()
  14. {
  15.     int a = 10;
  16.     return a;
  17. }
  18. //返回静态变量引用
  19. int& test02()
  20. {
  21.     static int b = 10;
  22.     return b;
  23. }
  25. int main()
  26. {
  27.     //不要返回局部变量的引用
  28.     int& ref = test01();
  29.     cout << "ref=" << ref << endl;
  30.     cout << "ref=" << ref << endl;
  32.     //如果函数做左值，那么必须返回引用
  33.     int& ref2 = test02();
  34.     cout << "ref2=" << ref2 << endl;
  35.     cout << "ref2=" << ref2 << endl;
  37.     test02() = 1000;
  39.     cout << "ref2=" << ref2 << endl;
  40.     cout << "ref2=" << ref2 << endl;
  42.     system("pause");
  43.     return 0;
  44. }

引用的本质

本质：引用本质在C++中内部实现是一个指针常量
结论：C++推荐用引用技术，因为语法方便，引用本质为指针常量，但是所有指针操作编译器都帮我们做了

常量引用

  1. #include<iostream> //头文件
  2. #include<string>
  3. using namespace std;
  6. //打印函数
  7. void showvalue(const int& val)  //添加const,形参无法改变
  8. {
  9.     //val = 1000;    形参无法改变
  10.     cout << "val=" << val << endl;
  12. }
  14. int main()
  15. {
  16.     //常量引用
  17.     //使用场景：用来修饰形参，防止误操作
  18.     int a = 100;
  19.     showvalue(a);
  21.     system("pause");
  22.     return 0;
  23. }

函数提高

函数默认参数

在C++中，函数的形参列表中的形参是可以有默认值的。
语法：返回值类型 函数名 （参数 = 默认值）{ }

  1. #include<iostream> //头文件
  2. #include<string>
  3. using namespace std;
  6. //函数默认参数
  7. //如果我们自己传入数据，有用自己的数据，没有就用默认值
  8. //语法：返回值类型 函数名（形参=默认值）{}
  9. int func(int a,int b = 20,int c = 30)   //b和c用的默认值
  10. {
  11.     return a + b + c;
  12. }
  14. int func2(int a = 10, int b = 10);     //2、如果函数声明有默认参数，函数实现就不能有默认参数
  16. int main()
  17. {
  18.     //注意事项
  19.     //1、如果某个位置有了默认参数，那么从这个位置往后的形参都要有默认值
  20.     cout << func(10) << endl; //b和c使用形参列表中的默认值
  21.     cout << func(10, 30) << endl; //b使用实参列表中的值
  22.     cout << func2(10, 10) << endl;
  23. }
  25. int func2(int a,int b)//函数实现就不能有默认参数
  26. {
  27.     return a + b;
  28. }

函数占位参数

C++中函数的形参列表里可以有占位参数，用来做占位，调用函数时必须填补该变量
语法：返回值类型 函数名（数据类型）{}

  1. #include<iostream> //头文件
  2. #include<string>
  3. using namespace std;
  6. //占位参数
  7. //语法：返回值类型 函数名（数据类型）{}
  8. //占位参数还可以是默认参数
  9. void func(int a, int = 10)
  10. {
  11.     cout << "this is func" << endl;
  12. }
  14. int main()
  15. {
  16.     func(10, 10);
  18.     system("pause");
  20.     return 0;
  21. }

函数重载-基本语法

作用：函数名可以相同，提高函数名的复用性
函数重载满足条件：

  • 同一作用域下
  • 函数名相同
  • 函数参数类型不同或个数不同或顺序不同

注意：函数返回值不可以作为函数重载的条件

  1. #include<iostream> //头文件
  2. #include<string>
  3. using namespace std;
  5. //函数重载
  6. //可以让函数名重复使用，提高复用性
  7. // 满足条件：
  8. //1、同一作用域下
  9. //2、函数名称相同
  10. //3、函数参数类型不同，个数不同，顺序不同
  11. void func()
  12. {
  13.     cout << "" << endl;
  14. }
  16. void func(int a)
  17. {
  18.     cout << "this is func" << endl;
  19. }
  21. void func(int a, double b)  //形参数目不同
  22. {
  23.     cout << "3" << endl;
  24. }
  26. void func(double a, int b)  //形参顺序不同
  27. {
  28.     cout << "4" << endl;
  29. }
  32. int main()
  33. {
  34.     func();  // 调用第一个func函数
  35.     func(10);//调用第二个func函数
  37.     system("pause");
  39.     return 0;
  40. }

函数重载-注意事项

  • 引用作为重载条件
  • 函数重载碰到默认参数（尽量避免出现） ```cpp

    include //头文件

    include

    using namespace std;

//函数重载的注意事项 //1、引用作为重载条件 void func(int& a) { cout << “func(int &a)调用” << endl; }

void func(const int& a) { cout << “func(const int &a)调用” << endl; }

//2、函数重载碰到默认参数 void func2(int a, int b = 10) { cout << “调用func2(int a, int b = 10)” << endl; }

void func2(int a) { cout << “调用func2(int a)” << endl; }

int main() { int a = 10; func(a); //调用第一个函数版本 func(10); //调用第二个函数版本

  1. system("pause");
  2. return 0;

}

  1. <a name="Y2wfK"></a>
  2. ### 类和对象
  3. <a name="NXubl"></a>
  4. ### 封装（*）
  5. C++面向对象的三大特性：封装、继承、多态
  6. <a name="mZP2G"></a>
  7. #### 封装的意义一
  8. 语法：class 类名{}；<br />类中的属性和行为都称为“成员”<br />属性---成员属性   成员变量<br />行为---成员函数   成员方法
  9. ```cpp
  10. #include<iostream> //头文件
  11. #include<string>
  12. using namespace std;
  14. //设计一个圆类，求圆的周长
  15. //圆周长公式：2*PI*半径
  17. const double PI = 3.14;
  18. //class 代表设计一个类
  19. class Circle
  20. {
  21.     //访问权限
  22.     //公共权限
  23. public:
  25.     //属性
  26.     //半径
  27.     int m_r;
  29.     //行为
  30.     //获取圆的周长
  31.     double calculateZC()
  32.     {
  33.         return 2 * PI * m_r;
  34.     }
  35. };
  37. int main()
  38. {
  39.     //通过圆类 创建具体的圆（对象）
  40.     Circle cl;
  41.     //给圆对象的属性进行赋值
  42.     cl.m_r = 10;
  44.     cout << "圆的周长为：" << cl.calculateZC() << endl;
  46.     system("pause");
  47.     return 0;
  48. }
  1. #include<iostream> //头文件
  2. #include<string>
  3. using namespace std;
  5. //设计一个学生类，可以给学生姓名和学号赋值，可以显示学生姓名和学号
  7. class Student
  8. {
  9.     //访问权限
  10.     //公共权限
  11. public:
  12.     //属性
  13.     //学生姓名和学号
  14.     string Name;
  15.     string Number;
  17.     //行为
  18.     void print()
  19.     {
  20.         cout << "学生姓名为：" << Name << endl;
  21.         cout << "学生学号为：" << Number << endl;
  22.     }
  24. };
  26. int main()
  27. {
  28.     string name;
  29.     cout << "请输入学生的姓名：" << endl;
  30.     cin >> name;
  32.     string number;
  33.     cout << "请输入学生的学号：" << endl;
  34.     cin >> number;
  36.     //生成一个学生类
  37.     Student st1;
  38.     st1.Name = name;
  39.     st1.Number = number;
  40.     st1.print(name, number);
  42.     system("pause");
  43.     return 0;
  44. }

封装意义二

封装权限：
1）public 公共权限，类内可以访问，类外也可以访问；
2）protected保护权限，类内可以访问，类外不可以访问，儿子可以访问父亲的保护内容；
2）private私有权限，类内可以访问，类外不可以访问，儿子不可以访问父亲的私有内容。

  1. #include<iostream> //头文件
  2. #include<string>
  3. using namespace std;
  5. //设计一个学生类，可以给学生姓名和学号赋值，可以显示学生姓名和学号
  7. class Person
  8. {
  9. public:
  10.     string name;
  11. protected:
  12.     string car;
  13. private:
  14.     int Password;
  16. public:
  17.     void func()
  18.     {
  19.         name = "张三";
  20.         car = "奔驰";   //类内可以访问
  21.         Password = 123456;     //类内可以访问        
  22.     }
  23. };
  25. int main()
  26. {
  27.     Person pr;
  28.     pr.name = "李四";  //类外仅可以访问公共权限
  29.     system("pause");
  30.     return 0;
  31. }

struct 和class的区别

C++中class和struct 的唯一区别在于默认权限不一样

  • srtuct：默认权限为公共权限
  • class：默认权限为私有权限

    封装-成员属性私有化

    优点：1）可以设置成员变量的读/写的权限；2）对于写可以检测数据的有效性 ```cpp class Person { public: //姓名 可写 void setName(string name) {
    1.   m_Name = name;
    } //姓名 可读 string getname() {
    1.   return m_Name;
    } //获取年龄 只读 int getAge() {
    1.   m_Age = 0;
    2.   return m_Age;
    } //设置情人 只写 void setlover(string lover) {
    1.   m_Lover = lover;
    }

private: //姓名 可读可写 string m_Name; //年龄 只读 int m_Age; //情人 只写 string m_Lover; };

  1. <a name="v5Arm"></a>
  2. #### 封装-案例2
  4. - **在类中可以将另一个类作为成员**
  5. - **如将类与成员函数分开写，简化代码**
  7. 头文件：
  8. ```cpp
  9. #pragma once
  10. #include<iostream>
  11. //头文件中对类中成员进行声明
  12. class point
  13. {
  14. public:
  15.     //成员函数声明
  16.     //设置x
  17.     void setX(int x);
  18.     //获取x
  19.     int getX();
  20.     //设置y
  21.     void setY(int y);
  22.     //获取y
  23.     int getY();
  24. private:
  25.     //成员变量声明
  26.     int m_X;
  27.     int m_Y;
  28. };
  1. #pragma once
  2. #include<iostream>
  3. #include"point.h"
  4. class circle
  5. {
  6. public:
  7.     //设置半径
  8.     void setR(int r);
  9.     //获取半径
  10.     int getR();
  11.     //设置圆心
  12.     void setCenter(point center);
  13.     //获取圆心
  14.     point getCenter();
  15. private:
  16.     //半径
  17.     int m_R;
  18.     //圆心
  19.     point m_Center;
  20. };

源文件：

  1. #include<iostream> //头文件
  2. #include<string>
  3. #include"circle.h"
  4. #include"point.h"
  5. using namespace std;
  7. void isInCircle(circle& c, point& p)
  8. {
  9.     //计算距离平方
  10.     int distance =
  11.         (c.getCenter().getX() - p.getX()) * (c.getCenter().getX() - p.getX()) +
  12.         (c.getCenter().getY() - p.getY()) * (c.getCenter().getY() - p.getY());
  13.     //计算半径平方
  14.     int rdistance = c.getR() * c.getR();
  16.     //判断位置关系
  17.     if (distance == rdistance)
  18.     {
  19.         cout << "点在圆上" << endl;
  20.     }
  21.     else if (distance > rdistance)
  22.     {
  23.         cout << "点在圆外" << endl;
  24.     }
  25.     else
  26.     {
  27.         cout << "点在圆内" << endl;
  28.     }
  29. }
  31. int main()
  32. {
  33.     circle c;
  34.     point p;
  36.     p.setX(10);
  37.     p.setY(10);
  38.     c.setR(10);
  39.     c.setCenter(p);
  41.     isInCircle(c, p);
  43.     system("pause");
  44.     return 0;
  45. }
  1. #include"point.h"
  2. #include<iostream>
  3. void point::setX(int x)
  4. {
  5.     m_X = x;
  6. }
  8. int point::getX()
  9. {
  10.     return m_X;
  11. }
  13. void point::setY(int y)
  14. {
  15.     m_Y = y;
  16. }
  18. int point::getY()
  19. {
  20.     return m_Y;
  21. }
  1. #include"circle.h"
  2. #include<iostream>
  3. void circle::setR(int r)
  4. {
  5.     m_R = r;
  6. }
  8. int circle::getR()
  9. {
  10.     return m_R;
  11. }
  13. void circle::setCenter(point center)
  14. {
  15.     m_Center = center;
  16. }
  18. point circle::getCenter()
  19. {
  20.     return m_Center;
  21. }

对象初始化和清理（？）

构造函数和析构函数

两个函数将会被编译器自动调用

  • 构造函数：作用在于创建对象时为对象的成员属性赋值，语法： 类名（）{}
  • 析构函数：主要作用在于对象销毁前系统自动调用，语法：~类名（）{} ```cpp

    include //头文件

    include

    using namespace std;

//对象的初始化和清理 //1、构造函数 进行初始化操作 class Person { public: //1、构造函数 //没有返回值 不用写void //函数名 与类名相同 //构造函数可以有参数，可以发生重载 //创建对象的时候，构造函数会自动调用，而且只调用一次 Person() { cout << “Person构造函数的调用” << endl; } //2、析构函数 进行清理的操作 //没有返回值 不用写void //函数名和类名相同 在名称前加~ //析构函数不可以有参数的，不可以发生重载 //对象销毁前 会自动调用析构函数 而且只调用一次 ~Person() { cout << “Person析构函数的调用” << endl; } };

void test01() { Person p; // 在栈上的数据，在test01执行完毕后，释放这个对象 }

int main() { test01();//调用test01函数

  1. system("pause");
  2. return 0;

}

  1. <a name="buhdj"></a>
  2. #### 构造函数的分类及应用
  3. ```cpp
  4. #include<iostream>
  5. #include<string>
  6. using namespace std;
  7. //1、构造函数分类
  8. //按照参数分类分为有参和无参构造  午餐又称为默认构造函数
  9. //按照类型分类分为 普通构造和拷贝构造
  10. class Person 
  11. {
  12. public:
  13.     //无参（默认）构造函数
  14.     Person()
  15.     {
  16.         cout << "无参构造函数！" << endl;
  17.     }
  18.     //有参构造函数
  19.     Person(int a)
  20.     {
  21.         age = a;
  22.         cout << "有参构造函数！" << endl;
  23.     }
  24.     //拷贝构造函数
  25.     Person(const Person &P)      //注意形参的写法
  26.     {
  27.         //将传入的人身上的所有属性，拷贝到我身上
  28.         age = P.age;
  29.         cout << "拷贝函数！" << endl;
  30.     }
  31.     //析构函数
  32.     ~Person()
  33.     {
  34.         cout << "析构函数！" << endl;
  35.     }
  36. public:
  37.     int age;
  38. };
  40. void test02()
  41. {
  42.     //1、括号法
  43.     Person p1;   //默认构造函数调用
  44.     Person p2(10); // 有参构造函数
  45.     Person p3(p2);   //拷贝构造函数调用
  46.     //注意事项
  47.     //调用默认函数时，不要加（）
  48.     //因为下面这行代码，编译器会认为时一个函数的声明
  50.     //2、显示法
  51.     //Person p1;
  52.     //Person p2 = Person(10);  //有参构造
  53.     //Person p3 = Person(p2);  //拷贝函数
  55.     //注意事项2
  56.     //不要利用拷贝构造函数，初始化匿名对象
  58.     //3、隐式转换法
  59.     //Person p4 = 10;  //相当于写了 Person p4 = Person(10)，有参构造
  60.     //Person p5 = p4;  //拷贝构造
  61. }
  62. int main()
  63. {
  64.     test02();
  66.     system("pause");
  68.     return 0;
  70. }

拷贝构造函数调用时机

image.png

  1. #include<iostream>
  2. #include<string>
  3. using namespace std;
  4. //拷贝构造函数调用时机
  5. //1、使用一个已经创建完毕的对象来初始化一个新对象
  7. //2、值传递的方式给函数参数传值
  9. //3、值方式返回局部对象
  11. class Person 
  12. {
  13. public:
  14.     Person()
  15.     {
  16.         cout << "Person默认构造函数调用" << endl;
  17.     }
  18.     Person(int age)
  19.     {
  20.         m_Age = age;
  21.     }
  23.     Person(const Person& p)
  24.     {
  25.         cout << "Person拷贝构造函数调用" << endl;
  26.         m_Age = p.m_Age;
  27.     }
  30.     ~Person()
  31.     {
  32.         cout << "Person析构函数调用" << endl;
  33.     }
  34.     int m_Age;
  35. };
  37. //1、使用一个已经创建完毕的对象来初始化一个新对象
  38. void test01()
  39. {
  40.     Person p1(20);
  41.     Person p2(p1);
  43.     cout << "p2的年龄为：" <<p2.m_Age<< endl;
  44. }
  45. //2、值传递的方式给函数参数传值
  47. void dowork(Person p)
  48. {
  50. }
  51. void test02()
  52. {
  53.     Person p;
  54.     dowork(p);
  56. }
  58. //3、值方式返回局部对象
  59. Person dowork2()
  60. {
  61.     Person p1;
  62.     return p1;
  64. }
  65. void test03()
  66. {
  67.     Person p = dowork2();
  68. }
  70. int main()
  71. {
  72.     test01();
  73.     test02();
  74.     test03();
  76.     system("pause");
  78.     return 0;
  80. }

构造函数的调用规则

image.png

  1. #include<iostream>
  2. #include<string>
  3. using namespace std;
  4. //构造函数的调用规则
  5. //1、创建一个类，C++编译器会给每个类都添加至少3个函数
  6. //默认构造（空实现）
  7. // 析构函数（空实现）
  8. //拷贝构造（值拷贝）
  10. class Person
  11. {
  12. public:
  13.     Person()
  14.     {
  15.         cout << "Person的默认构造函数调用" << endl;
  16.     }
  17.     Person(int age)
  18.     {
  19.         cout << "Person的有参构造函数调用" << endl;
  20.         m_Age = age;
  21.     }
  22.     Person(const Person& p)
  23.     {
  24.         cout << "Person的拷贝造函数调用" << endl;
  25.         m_Age = p.m_Age;
  26.     }
  27.     ~Person()
  28.     {
  29.         cout << "" << endl;
  31.     }
  32.     int m_Age;
  33. };
  34. //2、
  35. //如果有了有参构造函数，编译器就不再提供默认构造函数，但是会提供拷贝构造函数
  36. //如果我们写了拷贝构造函数，编译器就不再提供其他构造函数
  37. void test01()
  38. {
  39.     Person p;
  40.     p.m_Age = 18;
  41.     Person p2(p);
  42.     cout << "p2的年龄为：" << p2.m_Age << endl;
  43. }
  47. int main()
  48. {
  49.     test01();
  51.     system("pause");
  53.     return 0;
  55. }

深拷贝和浅拷贝

image.png
浅拷贝带来的问题就是堆区的内存重复释放，需要利用深拷贝的问题来进行解决

  1. #include<iostream>
  2. #include<string>
  3. using namespace std;
  4. //深拷贝与浅拷贝
  6. class Person
  7. {
  8. public:
  9.     Person()
  10.     {
  11.         cout << "调用默认构造函数" << endl;
  13.     }
  14.     Person(int age, int height)
  15.     {
  16.         m_Age = age;
  17.         m_Height = new int(height);
  18.         cout << "Person的有参构造函数调用" << endl;
  20.     }
  21.     //自己实现拷贝构造函数 解决浅拷贝带来的问题
  22.     Person()
  23.     {
  24.         cout << "Person kaobei hanshu s" << endl;
  26.     }
  27.     ~Person()
  28.      {
  29.         //析构代码，将堆区开辟的数据做释放操作
  30.         if (m_Height != NULL)
  31.         {
  32.             delete m_Height;
  33.             m_Height = NULL;
  35.         }
  36.         cout << "Person的析构函数调用" << endl;
  37.      }
  39.     int m_Age;    //年龄
  40.     int* m_Height; //身高
  43. };
  46. int main()
  47. {
  48.     test01();
  50.     system("pause");
  52.     return 0;
  54. }

初始化列表

  1. #include<iostream>
  2. #include<string>
  3. using namespace std;
  4. //初始化列表
  5. class Person
  6. {
  7. public:
  8.     //传统初始化操作
  9.     //int m_A;
  10.     //int m_B;
  11.     //int m_C;
  12.     //初始化列表初始化属性
  13.     Person(int a, int b, int c) :m_A(a),m_B(b),m_C(c)
  14.     {
  16.     }
  17.     int m_A;
  18.     int m_B;
  19.     int m_C;
  20. };
  22. int main()
  23. {
  24.     Person p(30, 20, 10);
  25.     cout << "m_A:" << p.m_A << endl;
  26.     cout << "m_B" << p.m_B << endl;
  27.     cout << "m_C:" << p.m_C << endl;
  29.     system("pause");
  31.     return 0;
  33. }

类对象作为类成员

C++类中的成员可以作为另一个类中的对象，我们称之为对象成员

  1. #include<iostream>
  2. #include<string>
  3. using namespace std;
  4. //类对象作为类成员
  6. //手机类
  7. class Phone
  8. {
  9. public:
  10.     Phone(string pName)
  11.     {
  12.         m_PName = pName;
  13.         cout << "phone的构造函数调用" << endl;
  14.     }
  15.     ~Phone()
  16.     {
  17.         cout << "Phone的析构函数调用" << endl;
  19.     }
  20.     string m_PName;
  21. };
  23. class Person
  24. {
  25. public:
  26.     //Phone m_Phone = pName  隐式转化法
  27.     Person(string name, string pName) :m_Name(name), m_Phone(pName)
  28.     {
  29.         cout << "Person的构造函数调用" << endl;
  30.     }
  31.     ~Person()
  32.     {
  33.         cout << "Person的析构函数调用" << endl;
  35.     }
  36.     //姓名
  37.     string m_Name;
  38.     //手机
  39.     Phone m_Phone;
  40. };
  41. //当其他类对象作为本类成员，构造时先构造对象，在构造自身，析构的顺序与构造相反
  43. void test01()
  44. {
  45.     Person p("张三","苹果");
  46.     cout<<p.m_Name << "拿着" << p.m_Phone.m_PName << endl;
  47. }
  48. int main()
  49. {
  50.     test01();
  52.     system("pause");
  54.     return 0;
  56. }

静态成员

image.png

  1. #include<iostream>
  2. #include<string>
  3. using namespace std;
  5. //静态成员
  6. class Person
  7. {
  8. public:
  9.     static int m_A;
  11.     //静态成员变量也有访问权限
  13. private:
  14.     static int m_B;};
  16. int Person::m_A = 100;
  18. void test01()
  19. {
  20.     //静态成员变量，不属于某个对象上，所有对象都可以共享同一份数据
  22.     //因此静态成员变量有两种访问方式
  23.     //1、通过对象访问
  24.     Person p1;
  25.     cout << p1.m_A << endl;
  28.     //2、通过类名进行访问
  29.     cout << Person::m_A << endl;
  31. }
  32. int main()
  33. {
  34.     test01();
  36.     system("pause");
  38.     return 0;
  40. }

C++对象模型和this指针

this指针概念

image.png

  1. #include<iostream>
  2. #include<string>
  3. using namespace std;
  5. class Person
  6. {
  7. public:
  8.     Person(int age)
  9.     {
  10.         this->age = age;  //this指针指向被调用成员函数的所属对象
  12.     }
  14.     Person& PersonAddAge(Person p)
  15.     {
  16.         Person p1(10);
  17.         this->age += p1.age;
  18.         return *this;
  19.     }
  20.     int age;
  22. };
  23. //1、解决名称冲突
  24. void test01()
  25. {
  26.     Person p1(18);
  27.     cout << "p1的年龄为：" << p1.age << endl;
  28. }
  30. //2、返回对象本身*this
  31. void test02()
  32. {
  33.     Person p1(10);
  35.     Person p2(10);
  37.     p2.PersonAddAge(p1).PersonAddAge(p1).PersonAddAge(p1);
  39.     cout << "p2的年龄为：" << p2.age << endl;
  41. }
  43. int main()
  44. {
  45.     test01();
  46.     test02();
  48.     system("pause");
  50.     return 0;
  52. }

空指针访问成员函数

image.png

Const修饰成员函数

image.png

  1. #include<iostream>
  2. #include<string>
  3. using namespace std;
  5. //空指针调用成员函数
  7. class Person {
  8. public:
  9.     Person() {
  10.         m_A = 0;
  11.         m_B = 0;
  12.     }
  14.     //this指针的本质是一个指针常量，指针的指向不可修改
  15.     //如果想让指针指向的值也不可以修改，需要声明常函数
  16.     void ShowPerson() const {
  17.         //const Type* const pointer;
  18.         //this = NULL; //不能修改指针的指向 Person* const this;
  19.         //this->mA = 100; //但是this指针指向的对象的数据是可以修改的
  21.         //const修饰成员函数，表示指针指向的内存空间的数据不能修改，除了mutable修饰的变量
  22.         this->m_B = 100;
  23.     }
  25.     void MyFunc() const {
  26.         //mA = 10000;
  27.     }
  29. public:
  30.     int m_A;
  31.     mutable int m_B; //可修改 可变的
  32. };
  35. //const修饰对象  常对象
  36. void test01() {
  38.     const Person person; //常量对象  
  39.     cout << person.m_A << endl;
  40.     //person.mA = 100; //常对象不能修改成员变量的值,但是可以访问
  41.     person.m_B = 100; //但是常对象可以修改mutable修饰成员变量
  43.     //常对象访问成员函数
  44.     person.MyFunc(); //常对象不能调用const的函数
  46. }
  48. int main() {
  50.     test01();
  52.     system("pause");
  54.     return 0;
  55. }

友元

生活中你的家有客厅(Public)，有你的卧室(Private)
客厅所有来的客人都可以进去，但是你的卧室是私有的，也就是说只有你能进去
但是呢，你也可以允许你的好闺蜜好基友进去。
在程序里，有些私有属性 也想让类外特殊的一些函数或者类进行访问，就需要用到友元的技术
友元的目的就是让一个函数或者类 访问另一个类中私有成员
友元的关键字为 ==friend==

全局函数做友元

  1. #include<iostream>
  2. #include<string>
  3. using namespace std;
  5. class Building
  6. {
  7.     //告诉编译器 goodGay全局函数 是 Building类的好朋友，可以访问类中的私有内容
  8.     friend void goodGay(Building* building);
  10. public:
  12.     Building()
  13.     {
  14.         this->m_SittingRoom = "客厅";
  15.         this->m_BedRoom = "卧室";
  16.     }
  19. public:
  20.     string m_SittingRoom; //客厅
  22. private:
  23.     string m_BedRoom; //卧室
  24. };
  27. void goodGay(Building* building)
  28. {
  29.     cout << "好基友正在访问： " << building->m_SittingRoom << endl;
  30.     cout << "好基友正在访问： " << building->m_BedRoom << endl;
  31. }
  34. void test01()
  35. {
  36.     Building b;
  37.     goodGay(&b);
  38. }
  40. int main() {
  42.     test01();
  44.     system("pause");
  45.     return 0;
  46. }

类做友元

  1. #include<iostream>
  2. #include<string>
  3. using namespace std;
  5. class Building;
  6. class goodGay
  7. {
  8. public:
  10.     goodGay();
  11.     void visit();
  13. private:
  14.     Building* building;
  15. };
  18. class Building
  19. {
  20.     //告诉编译器 goodGay类是Building类的好朋友，可以访问到Building类中私有内容
  21.     friend class goodGay;
  23. public:
  24.     Building();
  26. public:
  27.     string m_SittingRoom; //客厅
  28. private:
  29.     string m_BedRoom;//卧室
  30. };
  32. Building::Building() //类内定义，类外实现
  33. {
  34.     this->m_SittingRoom = "客厅";
  35.     this->m_BedRoom = "卧室";
  36. }
  38. goodGay::goodGay()
  39. {
  40.     building = new Building;
  41. }
  43. void goodGay::visit()
  44. {
  45.     cout << "好基友正在访问" << building->m_SittingRoom << endl;
  46.     cout << "好基友正在访问" << building->m_BedRoom << endl;
  47. }
  49. void test01()
  50. {
  51.     goodGay gg;
  52.     gg.visit();
  54. }
  56. int main() {
  58.     test01();
  60.     system("pause");
  61.     return 0;
  62. }

成员函数做友元

  1. #include<iostream>
  2. #include<string>
  3. using namespace std;
  6. class Building;
  7. class goodGay
  8. {
  9. public:
  11.     goodGay();
  12.     void visit(); //只让visit函数作为Building的好朋友，可以发访问Building中私有内容
  13.     void visit2();
  15. private:
  16.     Building* building;
  17. };
  20. class Building
  21. {
  22.     //告诉编译器  goodGay类中的visit成员函数 是Building好朋友，可以访问私有内容
  23.     friend void goodGay::visit();
  25. public:
  26.     Building();
  28. public:
  29.     string m_SittingRoom; //客厅
  30. private:
  31.     string m_BedRoom;//卧室
  32. };
  34. Building::Building()
  35. {
  36.     this->m_SittingRoom = "客厅";
  37.     this->m_BedRoom = "卧室";
  38. }
  40. goodGay::goodGay()
  41. {
  42.     building = new Building;
  43. }
  45. void goodGay::visit()
  46. {
  47.     cout << "好基友正在访问" << building->m_SittingRoom << endl;
  48.     cout << "好基友正在访问" << building->m_BedRoom << endl;
  49. }
  51. void goodGay::visit2()
  52. {
  53.     cout << "好基友正在访问" << building->m_SittingRoom << endl;
  54.     //cout << "好基友正在访问" << building->m_BedRoom << endl;
  55. }
  57. void test01()
  58. {
  59.     goodGay  gg;
  60.     gg.visit();
  62. }
  64. int main() {
  66.     test01();
  68.     system("pause");
  69.     return 0;
  70. }

运算符重载

运算符重载概念：对已有的运算符重新进行定义，赋予其另一种功能，以适应不同的数据类型

加号运算符重载

作用：实现两个自定义数据类型相加的运算

  1. #include<iostream>
  2. #include<string>
  3. using namespace std;
  6. class Person {
  7. public:
  8.     Person() {};
  9.     Person(int a, int b)
  10.     {
  11.         this->m_A = a;
  12.         this->m_B = b;
  13.     }
  14.     //1、成员函数实现 + 号运算符重载
  15.     Person operator+(const Person& p) {
  16.         Person temp;
  17.         temp.m_A = this->m_A + p.m_A;
  18.         temp.m_B = this->m_B + p.m_B;
  19.         return temp;
  20.     }
  23. public:
  24.     int m_A;
  25.     int m_B;
  26. };
  28. //2、全局函数实现 + 号运算符重载
  29. //Person operator+(const Person& p1, const Person& p2) {
  30. //    Person temp(0, 0);
  31. //    temp.m_A = p1.m_A + p2.m_A;
  32. //    temp.m_B = p1.m_B + p2.m_B;
  33. //    return temp;
  34. //}
  36. //运算符重载 可以发生函数重载(形参类型不同，实现函数重载) 
  37. Person operator+(const Person& p2, int val)
  38. {
  39.     Person temp;
  40.     temp.m_A = p2.m_A + val;
  41.     temp.m_B = p2.m_B + val;
  42.     return temp;
  43. }
  45. void test() {
  47.     Person p1(10, 10);
  48.     Person p2(20, 20);
  50.     //成员函数方式
  51.     Person p3 = p2 + p1;  //相当于 p2.operaor+(p1)
  52.     cout << "mA:" << p3.m_A << " mB:" << p3.m_B << endl;
  54.     Person p4 = p3 + 10; //相当于 operator+(p3,10)
  55.     cout << "mA:" << p4.m_A << " mB:" << p4.m_B << endl;
  56. }
  58. int main() {
  60.     test();
  62.     system("pause");
  64.     return 0;
  65. }

PS：总结1：对于内置的数据类型的表达式的的运算符是不可能改变的
总结2：不要滥用运算符重载

左移运算符重载（？）

作用：可以输出自定义数据类型
通常不利用成员函数重载左移运算符

  1. #include<iostream>
  2. #include<string>
  3. using namespace std;
  6. class Person
  7. {
  8.     friend ostream& operator<<(ostream& out, Person& p);
  10. public:
  12.     Person(int a, int b)
  13.     {
  14.         this->m_A = a;
  15.         this->m_B = b;
  16.     }
  18.     //成员函数 实现不了  p << cout 不是我们想要的效果
  19.     //void operator<<(Person& p){
  20.     //}
  22. private:
  23.     int m_A;
  24.     int m_B;
  25. };
  27. //全局函数实现左移重载
  28. //ostream对象只能有一个
  29. ostream& operator<<(ostream& out, Person& p) {
  30.     out << "a:" << p.m_A << " b:" << p.m_B;
  31.     return out;
  32. }
  34. void test() {
  36.     Person p1(10, 20);
  38.     cout << p1 << "hello world" << endl; //链式编程
  39. }
  41. int main() {
  43.     test();
  45.     system("pause");
  47.     return 0;
  48. }

总结：重载左移运算符配合友元可以实现输出自定义数据类型

递增运算符重载

作用： 通过重载递增运算符，实现自己的整型数据

  1. #include<iostream>
  2. #include<string>
  3. using namespace std;
  5. class MyInteger {
  7.     friend ostream& operator<<(ostream& out, MyInteger myint);
  9.     public:
  10.     MyInteger() {
  11.         m_Num = 0;
  12.     }
  13.     //前置++
  14.     MyInteger& operator++() {
  15.         //先++
  16.         m_Num++;
  17.         //再返回
  18.         return *this;
  19.     }
  21.     //后置++
  22.     MyInteger operator++(int) {
  23.         //先返回
  24.         MyInteger temp = *this; //记录当前本身的值，然后让本身的值加1，但是返回的是以前的值，达到先返回后++；
  25.         m_Num++;
  26.         return temp;
  27.     }
  29.     private:
  30.     int m_Num;
  31. };
  34. ostream& operator<<(ostream& out, MyInteger myint) {
  35.     out << myint.m_Num;
  36.     return out;
  37. }
  40. //前置++ 先++ 再返回
  41. void test01() {
  42.     MyInteger myInt;
  43.     cout << ++myInt << endl;
  44.     cout << myInt << endl;
  45. }
  47. //后置++ 先返回 再++
  48. void test02() {
  50.     MyInteger myInt;
  51.     cout << myInt++ << endl;
  52.     cout << myInt << endl;
  53. }
  55. int main() {
  57.     test01();
  58.     //test02();
  60.     system("pause");
  62.     return 0;
  63. }

总结： 前置递增返回引用，后置递增返回值

赋值运算符重载

c++编译器至少给一个类添加4个函数：

  1. 默认构造函数(无参，函数体为空)
  2. 默认析构函数(无参，函数体为空)
  3. 默认拷贝构造函数，对属性进行值拷贝
  4. 赋值运算符 operator=, 对属性进行值拷贝

如果类中有属性指向堆区，做赋值操作时也会出现深浅拷贝问题

  1. #include<iostream>
  2. #include<string>
  3. using namespace std;
  5. class Person
  6. {
  7. public:
  9.     Person(int age)
  10.     {
  11.         //将年龄数据开辟到堆区
  12.         m_Age = new int(age);
  13.     }
  15.     //重载赋值运算符 
  16.     Person& operator=(Person &p)
  17.     {
  18.         if (m_Age != NULL)
  19.         {
  20.             delete m_Age;
  21.             m_Age = NULL;
  22.         }
  23.         //编译器提供的代码是浅拷贝
  24.         //m_Age = p.m_Age;
  26.         //提供深拷贝 解决浅拷贝的问题
  27.         m_Age = new int(*p.m_Age);
  29.         //返回自身
  30.         return *this;
  31.     }
  34.     ~Person()
  35.     {
  36.         if (m_Age != NULL)
  37.         {
  38.             delete m_Age;
  39.             m_Age = NULL;
  40.         }
  41.     }
  43.     //年龄的指针
  44.     int *m_Age;
  46. };
  49. void test01()
  50. {
  51.     Person p1(18);
  53.     Person p2(20);
  55.     Person p3(30);
  57.     p3 = p2 = p1; //赋值操作
  59.     cout << "p1的年龄为：" << *p1.m_Age << endl;
  61.     cout << "p2的年龄为：" << *p2.m_Age << endl;
  63.     cout << "p3的年龄为：" << *p3.m_Age << endl;
  64. }
  66. int main() {
  68.     test01();
  70.     //int a = 10;
  71.     //int b = 20;
  72.     //int c = 30;
  74.     //c = b = a;
  75.     //cout << "a = " << a << endl;
  76.     //cout << "b = " << b << endl;
  77.     //cout << "c = " << c << endl;
  79.     system("pause");
  81.     return 0;
  82. }

疑问：1）怎样区分栈区数据和堆区数据；2）深浅拷贝的作用和区别

关系运算符重载

作用：重载关系运算符，可以让两个自定义类型对象进行对比操作

  1. #include<iostream>
  2. #include<string>
  3. using namespace std;
  5. class Person
  6. {
  7. public:
  8.     Person(string name, int age)
  9.     {
  10.         this->m_Name = name;
  11.         this->m_Age = age;
  12.     };
  14.     bool operator==(Person & p)
  15.     {
  16.         if (this->m_Name == p.m_Name && this->m_Age == p.m_Age)
  17.         {
  18.             return true;
  19.         }
  20.         else
  21.         {
  22.             return false;
  23.         }
  24.     }
  26.     bool operator!=(Person & p)
  27.     {
  28.         if (this->m_Name == p.m_Name && this->m_Age == p.m_Age)
  29.         {
  30.             return false;
  31.         }
  32.         else
  33.         {
  34.             return true;
  35.         }
  36.     }
  38.     string m_Name;
  39.     int m_Age;
  40. };
  42. void test01()
  43. {
  44.     //int a = 0;
  45.     //int b = 0;
  47.     Person a("孙悟空", 18);
  48.     Person b("孙悟空", 18);
  50.     if (a == b)
  51.     {
  52.         cout << "a和b相等" << endl;
  53.     }
  54.     else
  55.     {
  56.         cout << "a和b不相等" << endl;
  57.     }
  59.     if (a != b)
  60.     {
  61.         cout << "a和b不相等" << endl;
  62.     }
  63.     else
  64.     {
  65.         cout << "a和b相等" << endl;
  66.     }
  67. }
  70. int main() {
  72.     test01();
  74.     system("pause");
  76.     return 0;
  77. }

函数调用运算符重载

  • 函数调用运算符 () 也可以重载
  • 由于重载后使用的方式非常像函数的调用，因此称为仿函数
  • 仿函数没有固定写法，非常灵活 ```cpp

    include

    include

    using namespace std;

class MyPrint { public: void operator()(string text) { cout << text << endl; }

}; void test01() { //重载的（）操作符 也称为仿函数 MyPrint myFunc; myFunc(“hello world”); }

class MyAdd { public: int operator()(int v1, int v2) { return v1 + v2; } };

void test02() { MyAdd add; int ret = add(10, 10); cout << “ret = “ << ret << endl;

  1. //匿名对象调用  
  2. cout << "MyAdd()(100,100) = " << MyAdd()(100, 100) << endl;

}

int main() {

  1. test01();
  2. test02();
  4. system("pause");
  6. return 0;

}

  1. <a name="QUZ5y"></a>
  2. ### 继承（*）
  3. <a name="g4E5u"></a>
  4. #### 基本语法
  5. 作用：减少重复代码
  6. ```cpp
  7. #include<iostream>
  8. #include<string>
  9. using namespace std;
  12. //公共页面
  13. class BasePage
  14. {
  15. public:
  16.     void header()
  17.     {
  18.         cout << "首页、公开课、登录、注册...（公共头部）" << endl;
  19.     }
  21.     void footer()
  22.     {
  23.         cout << "帮助中心、交流合作、站内地图...(公共底部)" << endl;
  24.     }
  25.     void left()
  26.     {
  27.         cout << "Java,Python,C++...(公共分类列表)" << endl;
  28.     }
  30. };
  32. //Java页面
  33. class Java : public BasePage  //语法
  34. {
  35. public:
  36.     void content()
  37.     {
  38.         cout << "JAVA学科视频" << endl;
  39.     }
  40. };
  41. //Python页面
  42. class Python : public BasePage
  43. {
  44. public:
  45.     void content()
  46.     {
  47.         cout << "Python学科视频" << endl;
  48.     }
  49. };
  50. //C++页面
  51. class CPP : public BasePage
  52. {
  53. public:
  54.     void content()
  55.     {
  56.         cout << "C++学科视频" << endl;
  57.     }
  58. };
  60. void test01()
  61. {
  62.     //Java页面
  63.     cout << "Java下载视频页面如下： " << endl;
  64.     Java ja;
  65.     ja.header();
  66.     ja.footer();
  67.     ja.left();
  68.     ja.content();
  69.     cout << "--------------------" << endl;
  71.     //Python页面
  72.     cout << "Python下载视频页面如下： " << endl;
  73.     Python py;
  74.     py.header();
  75.     py.footer();
  76.     py.left();
  77.     py.content();
  78.     cout << "--------------------" << endl;
  80.     //C++页面
  81.     cout << "C++下载视频页面如下： " << endl;
  82.     CPP cp;
  83.     cp.header();
  84.     cp.footer();
  85.     cp.left();
  86.     cp.content();
  89. }
  91. int main() {
  93.     test01();
  95.     system("pause");
  97.     return 0;
  98. }

继承方式

继承的语法：class 子类 : 继承方式 父类
继承方式一共有三种：

  • 公共继承
  • 保护继承
  • 私有继承

image.png、

  1. #include<iostream>
  2. #include<string>
  3. using namespace std;
  6. class Base1
  7. {
  8. public:
  9.     int m_A;
  10. protected:
  11.     int m_B;
  12. private:
  13.     int m_C;
  14. };
  16. //公共继承
  17. class Son1 :public Base1
  18. {
  19. public:
  20.     void func()
  21.     {
  22.         m_A; //可访问 public权限
  23.         m_B; //可访问 protected权限
  24.         //m_C; //不可访问
  25.     }
  26. };
  28. void myClass()
  29. {
  30.     Son1 s1;
  31.     s1.m_A; //其他类只能访问到公共权限
  32. }
  34. //保护继承
  35. class Base2
  36. {
  37. public:
  38.     int m_A;
  39. protected:
  40.     int m_B;
  41. private:
  42.     int m_C;
  43. };
  44. class Son2 :protected Base2
  45. {
  46. public:
  47.     void func()
  48.     {
  49.         m_A; //可访问 protected权限
  50.         m_B; //可访问 protected权限
  51.         //m_C; //不可访问
  52.     }
  53. };
  54. void myClass2()
  55. {
  56.     Son2 s;
  57.     //s.m_A; //不可访问
  58. }
  60. //私有继承
  61. class Base3
  62. {
  63. public:
  64.     int m_A;
  65. protected:
  66.     int m_B;
  67. private:
  68.     int m_C;
  69. };
  70. class Son3 :private Base3
  71. {
  72. public:
  73.     void func()
  74.     {
  75.         m_A; //可访问 private权限
  76.         m_B; //可访问 private权限
  77.         //m_C; //不可访问
  78.     }
  79. };
  80. class GrandSon3 :public Son3
  81. {
  82. public:
  83.     void func()
  84.     {
  85.         //Son3是私有继承，所以继承Son3的属性在GrandSon3中都无法访问到
  86.         //m_A;
  87.         //m_B;
  88.         //m_C;
  89.     }
  90. };

继承中的对象模型

父类中私有成员也是被子类继承下去了，只是由编译器给隐藏后访问不到

  1. #include<iostream>
  2. #include<string>
  3. using namespace std;
  6. class Base
  7. {
  8. public:
  9.     int m_A;
  10. protected:
  11.     int m_B;
  12. private:
  13.     int m_C; //私有成员只是被隐藏了，但是还是会继承下去
  14. };
  16. //公共继承
  17. class Son :public Base
  18. {
  19. public:
  20.     int m_D;
  21. };
  23. void test01()
  24. {
  25.     //16
  26.     //父类中所有非静态成员属性都会倍子类继承下去
  27.     //父类中私有成员属性被编译器隐藏了，因此访问不到，但确实被继承下去了
  28.     cout << "sizeof Son = " << sizeof(Son) << endl;
  29. }
  31. int main() {
  33.     test01();
  35.     system("pause");
  37.     return 0;
  38. }

继承中构造和析构顺序

子类继承父类后，当创建子类对象，也会调用父类的构造函数
问题：父类和子类的构造和析构顺序是谁先谁后？

  1. #include<iostream>
  2. #include<string>
  3. using namespace std;
  6. class Base
  7. {
  8. public:
  9.     Base()
  10.     {
  11.         cout << "Base构造函数!" << endl;
  12.     }
  13.     ~Base()
  14.     {
  15.         cout << "Base析构函数!" << endl;
  16.     }
  17. };
  19. class Son : public Base
  20. {
  21. public:
  22.     Son()
  23.     {
  24.         cout << "Son构造函数!" << endl;
  25.     }
  26.     ~Son()
  27.     {
  28.         cout << "Son析构函数!" << endl;
  29.     }
  31. };
  34. void test01()
  35. {
  36.     //继承中 先调用父类构造函数，再调用子类构造函数，析构顺序与构造相反
  37.     Son s;
  38. }
  40. int main() {
  42.     test01();
  44.     system("pause");
  46.     return 0;
  47. }

结论：继承中 先调用父类构造函数，再调用子类构造函数，析构顺序与构造相反。

继承中同名成员处理方式

  1. #include<iostream>
  2. #include<string>
  3. using namespace std;
  6. class Base {
  7. public:
  8.     Base()
  9.     {
  10.         m_A = 100;
  11.     }
  13.     void func()
  14.     {
  15.         cout << "Base - func()调用" << endl;
  16.     }
  18.     void func(int a)
  19.     {
  20.         cout << "Base - func(int a)调用" << endl;
  21.     }
  23. public:
  24.     int m_A;
  25. };
  28. class Son : public Base {
  29. public:
  30.     Son()
  31.     {
  32.         m_A = 200;
  33.     }
  35.     //当子类与父类拥有同名的成员函数，子类会隐藏父类中所有版本的同名成员函数
  36.     //如果想访问父类中被隐藏的同名成员函数，需要加父类的作用域
  37.     void func()
  38.     {
  39.         cout << "Son - func()调用" << endl;
  40.     }
  41. public:
  42.     int m_A;
  43. };
  45. void test01()
  46. {
  47.     Son s;
  49.     cout << "Son下的m_A = " << s.m_A << endl;
  50.     cout << "Base下的m_A = " << s.Base::m_A << endl;//添加父类的作用域，实现父类中同名成员的调用
  52.     s.func();
  53.     s.Base::func();
  54.     s.Base::func(10);
  56. }
  57. int main() {
  59.     test01();
  61.     system("pause");
  62.     return EXIT_SUCCESS;
  63. }

总结：

  1. 子类对象可以直接访问到子类中同名成员
  2. 子类对象加作用域可以访问到父类同名成员
  3. 当子类与父类拥有同名的成员函数，子类会隐藏父类中同名成员函数，加作用域可以访问到父类中同名函数

    继承中同名静态成员处理方式

    问题：继承中同名的静态成员在子类对象上如何进行访问？
    静态成员和非静态成员出现同名，处理方式一致
  • 访问子类同名成员 直接访问即可
  • 访问父类同名成员 需要加作用域 ```cpp

    include

    include

    using namespace std;

class Base { public: static void func() { cout << “Base - static void func()” << endl; } static void func(int a) { cout << “Base - static void func(int a)” << endl; }

  1. static int m_A;

};

int Base::m_A = 100;

class Son : public Base { public: static void func() { cout << “Son - static void func()” << endl; } static int m_A; };

int Son::m_A = 200;

//同名成员属性 void test01() { //通过对象访问 cout << “通过对象访问： “ << endl; Son s; cout << “Son 下 m_A = “ << s.m_A << endl; cout << “Base 下 m_A = “ << s.Base::m_A << endl;

  1. //通过类名访问
  2. cout << "通过类名访问： " << endl;
  3. cout << "Son  下 m_A = " << Son::m_A << endl;
  4. //第一个：：代表通过类名方式访问，第二个::代表访问父类作用域下
  5. cout << "Base 下 m_A = " << Son::Base::m_A << endl;

}

//同名成员函数 void test02() { //通过对象访问 cout << “通过对象访问： “ << endl; Son s; s.func(); s.Base::func();

  1. cout << "通过类名访问： " << endl;
  2. Son::func();
  3. Son::Base::func();
  4. //出现同名，子类会隐藏掉父类中所有同名成员函数，需要加作作用域访问
  5. Son::Base::func(100);

} int main() {

  1. //test01();
  2. test02();
  4. system("pause");
  6. return 0;

}

  1. **总结：同名静态成员处理方式和非静态处理方式一样，只不过有两种访问的方式（通过对象 和 通过类名）**
  2. <a name="jQJNr"></a>
  3. #### 多继承语法（不建议使用）
  4. C++允许**一个类继承多个类**<br />语法：class 子类 ：继承方式 父类1 ， 继承方式 父类2...<br />多继承可能会引发父类中有同名成员出现，需要加作用域区分<br />**C++实际开发中不建议用多继承**
  5. ```cpp
  6. #include<iostream>
  7. #include<string>
  8. using namespace std;
  11. class Base1 {
  12. public:
  13.     Base1()
  14.     {
  15.         m_A = 100;
  16.     }
  17. public:
  18.     int m_A;
  19. };
  21. class Base2 {
  22. public:
  23.     Base2()
  24.     {
  25.         m_A = 200;  //开始是m_B 不会出问题，但是改为mA就会出现不明确
  26.     }
  27. public:
  28.     int m_A;
  29. };
  31. //语法：class 子类：继承方式 父类1 ，继承方式 父类2 
  32. class Son : public Base2, public Base1
  33. {
  34. public:
  35.     Son()
  36.     {
  37.         m_C = 300;
  38.         m_D = 400;
  39.     }
  40. public:
  41.     int m_C;
  42.     int m_D;
  43. };
  46. //多继承容易产生成员同名的情况
  47. //通过使用类名作用域可以区分调用哪一个基类的成员
  48. void test01()
  49. {
  50.     Son s;
  51.     cout << "sizeof Son = " << sizeof(s) << endl;
  52.     cout << s.Base1::m_A << endl;
  53.     cout << s.Base2::m_A << endl;
  54. }
  56. int main() {
  58.     test01();
  60.     system("pause");
  62.     return 0;
  63. }

总结： 多继承中如果父类中出现了同名情况，子类使用时候要加作用域

菱形继承问题及解决方法（用的比较少）

菱形继承概念：
两个派生类继承同一个基类
又有某个类同时继承者两个派生类
这种继承被称为菱形继承，或者钻石继承

  1. #include<iostream>
  2. #include<string>
  3. using namespace std;
  6. class Animal
  7. {
  8. public:
  9.     int m_Age;
  10. };
  12. //继承前加virtual关键字后，变为虚继承
  13. //此时公共的父类Animal称为虚基类
  14. class Sheep : virtual public Animal {};
  15. class Tuo : virtual public Animal {};
  16. class SheepTuo : public Sheep, public Tuo {};
  18. void test01()
  19. {
  20.     SheepTuo st;
  21.     st.Sheep::m_Age = 100;
  22.     st.Tuo::m_Age = 200;
  23.     //当菱形继承，两个父类拥有相同数据，需要加以作用域区分
  24.     cout << "st.Sheep::m_Age = " << st.Sheep::m_Age << endl;
  25.     cout << "st.Tuo::m_Age = " << st.Tuo::m_Age << endl;
  26.     //利用虚继承解决同时继承两份数据的情况
  27.     cout << "st.m_Age = " << st.m_Age << endl;
  28. }
  31. int main() {
  33.     test01();
  35.     system("pause");
  37.     return 0;
  38. }

总结：

  • 菱形继承带来的主要问题是子类继承两份相同的数据，导致资源浪费以及毫无意义

  • 利用虚继承可以解决菱形继承问题

    多态（*）

    多态基本语法

    多态是C++面向对象三大特性之一
    多态分为两类

  • 静态多态: 函数重载 和 运算符重载属于静态多态，复用函数名

  • 动态多态: 派生类和虚函数实现运行时多态

静态多态和动态多态区别：

  • 静态多态的函数地址早绑定 - 编译阶段确定函数地址
  • 动态多态的函数地址晚绑定 - 运行阶段确定函数地址 ```cpp

    include

    include

    using namespace std;

class Animal { public: //Speak函数就是虚函数 //函数前面加上virtual关键字，变成虚函数，那么编译器在编译的时候就不能确定函数调用了。 virtual void speak() { cout << “动物在说话” << endl; } };

class Cat :public Animal { public: //函数重写 函数返回值 函数名 参数列表 完全相同 void speak() { cout << “小猫在说话” << endl; } };

class Dog :public Animal { public:

  1. void speak()
  2. {
  3.     cout << "小狗在说话" << endl;
  4. }

}; //我们希望传入什么对象，那么就调用什么对象的函数 //如果函数地址在编译阶段就能确定，那么静态联编 //如果函数地址在运行阶段才能确定，就是动态联编

void DoSpeak(Animal& animal) //通过父类的指针实现 { animal.speak(); } // //多态满足条件： //1、有继承关系 //2、子类重写父类中的虚函数 //多态使用： //父类指针或引用指向子类对象

void test01() { Cat cat; DoSpeak(cat);

  1. Dog dog;
  2. DoSpeak(dog);

}

int main() {

  1. test01();
  3. system("pause");
  5. return 0;

}

  1. 总结：<br />多态满足条件：
  3. - 有继承关系
  4. - 子类重写父类中的虚函数
  6. 多态使用条件：
  8. - 父类指针或引用指向子类对象
  10. 重写：函数返回值类型  函数名 参数列表 完全一致称为重写
  11. <a name="InYAY"></a>
  12. #### 多态原理剖析
  13. <a name="tV9R4"></a>
  14. #### 多态案例一
  15. ```cpp
  16. #include<iostream>
  17. #include<string>
  18. using namespace std;
  20. class Calculator 
  21. {
  22. public:
  23.     int getResult(string oper)
  24.     {
  25.         if (oper == "+")
  26.         {
  27.             return m_Num1 + m_Num2;
  28.         }
  29.         else if (oper == "-")
  30.         {
  31.             return m_Num1 - m_Num2;
  32.         }
  33.         else if (oper == "*")
  34.         {
  35.             return m_Num1 * m_Num2;
  36.         }    
  37.     }
  38.     //如果想扩展新的功能，需要修改源码
  39.     //在真实开发中，提倡 开闭原则
  40.     //开闭原则：对扩展开放，对修改关闭
  41.     int m_Num1;   //操作数1
  42.     int m_Num2;   //操作数2
  43. };
  45. //利用多态实现计算器
  46. //多态优点：
  47. //1、组织结构清晰
  48. //2、可读性强
  49. //3、有利于前期和后期的扩展和维护
  50. class AbstractCalculator : public Calculator
  51. {
  52. public:
  53.     virtual int getResult()
  54.     {
  55.         return 0;
  56.     }
  57.     int m_Num1;
  58.     int m_Num2;
  59. };
  60. //加法计算器类
  61. class AddCalculator : public AbstractCalculator
  62. {
  63.     int getResult()
  64.     {
  65.         return m_Num1 + m_Num2;
  66.     }
  67. };
  69. //减法计算器类
  70. class SubCalculator : public AbstractCalculator
  71. {
  72. public:
  73.     int getResult()
  74.     {
  75.         return m_Num1 - m_Num2;
  76.     }
  78. };
  79. //乘法计算器类
  80. class MulCalculator : public AbstractCalculator
  81. {
  82. public:
  83.     int getResult()
  84.     {
  85.         return m_Num1 * m_Num2;    
  86.     }
  87. };
  88. void test01()  //未使用多态的实现方法
  89. {
  90.     Calculator c;
  91.     c.m_Num1 = 10;
  92.     c.m_Num2 = 10;
  94.     cout << c.m_Num1<<"+" << c.m_Num2 << "=" << c.getResult("+") << endl;
  95.     cout << c.m_Num1 << "-" << c.m_Num2 << "=" << c.getResult("-") << endl;
  96.     cout << c.m_Num1 << "*" << c.m_Num2 << "=" << c.getResult("*") << endl;
  97. }
  99. void test02()  //使用多态实现
  100. {
  101.     //多态使用条件
  102.     //父类指针或者引用指向子类对象
  104.     //加法运算
  105.     AbstractCalculator* abc = new AddCalculator;
  106.     abc->m_Num1 = 10;
  107.     abc->m_Num2 = 10;
  108.     cout << abc->m_Num1 << "+" << abc->m_Num2 << "=" << abc->getResult() << endl;
  109.     //堆区数据，使用完需要销毁
  110.     delete abc;
  112.     //减法运算
  113.     abc = new SubCalculator;
  114.     abc->m_Num1 = 100;
  115.     abc->m_Num2 = 100;
  116.     cout << abc->m_Num1 << "-" << abc->m_Num2 << "=" << abc->getResult() << endl;
  117.     //堆区数据，使用完需要销毁
  118.     delete abc;
  120.     //乘法运算
  121.     abc = new MulCalculator;
  122.     abc->m_Num1 = 100;
  123.     abc->m_Num2 = 100;
  124.     cout << abc->m_Num1 << "*" << abc->m_Num2 << "=" << abc->getResult() << endl;
  125.     //堆区数据，使用完需要销毁
  126.     delete abc;
  128. }
  130. int main()
  131. {
  132.     test02();
  133.     system("pause");
  135.     return 0;
  137. }

总结：C++开发提倡利用多态设计程序架构，因为多态优点很多

纯虚函数与抽象类

在多态中，通常父类中虚函数的实现是毫无意义的，主要都是调用子类重写的内容
因此可以将虚函数改为纯虚函数
纯虚函数语法：virtual 返回值类型 函数名 （参数列表）= 0 ;
当类中有了纯虚函数，这个类也称为抽象类
抽象类特点：

  • 无法实例化对象
  • 子类必须重写抽象类中的纯虚函数，否则也属于抽象类 ```cpp

    include

    include

    using namespace std;

class Base { public: //纯虚函数 //类中只要有一个纯虚函数就称为抽象类 //抽象类无法实例化对象 //子类必须重写父类中的纯虚函数，否则也属于抽象类 virtual void func() = 0; };

class Son :public Base { public: virtual void func() { cout << “func调用” << endl; }; };

void test01() { Base * base = NULL; //base = new Base; // 错误，抽象类无法实例化对象 base = new Son; base->func(); delete base;//记得销毁 }

int main() {

  1. test01();
  3. system("pause");
  5. return 0;

}

  1. <a name="nKAnA"></a>
  2. #### 多态案列二：
  3. ```cpp
  4. #include<iostream>
  5. #include<string>
  6. using namespace std;
  8. //制作饮品
  9. class AbstractDrinking
  10. {
  11. public:
  12.     //煮水
  13.     virtual void Boil() = 0;
  14.     //冲泡
  15.     virtual void Brew() = 0;
  16.     //倒入杯中
  17.     virtual void PourInCup() = 0;
  18.     //加入辅料
  19.     virtual void PutSometing() = 0;
  20.     //制作饮品
  21.     void makeDrink()
  22.     {
  23.         Boil();
  24.         Brew();
  25.         PourInCup();
  26.         PutSometing();    
  27.     }
  28. };
  30. class Coffee : public AbstractDrinking
  31. {
  32. public:
  33.     //煮水
  34.     virtual void Boil()
  35.     {
  36.         cout << "煮农夫山泉" << endl;
  38.     };
  39.     //冲泡
  40.     virtual void Brew() 
  41.     {
  42.         cout << "冲泡" << endl;
  44.     };
  45.     //倒入杯中
  46.     virtual void PourInCup() 
  47.     {
  48.         cout << "倒入杯中" << endl;
  49.     };
  50.     //加入辅料
  51.     virtual void PutSometing() 
  52.     {
  53.         cout << "放入咖啡" << endl;
  54.     };
  55. };
  57. class Tea : public AbstractDrinking
  58. {
  59. public:
  60.     //煮水
  61.     virtual void Boil()
  62.     {
  63.         cout << "煮矿泉水" << endl;
  65.     };
  66.     //冲泡
  67.     virtual void Brew()
  68.     {
  69.         cout << "冲泡" << endl;
  71.     };
  72.     //倒入杯中
  73.     virtual void PourInCup()
  74.     {
  75.         cout << "倒入杯中" << endl;
  76.     };
  77.     //加入辅料
  78.     virtual void PutSometing()
  79.     {
  80.         cout << "放入柠檬" << endl;
  81.     };
  82. };
  84. void doWork(AbstractDrinking* abs)
  85. {
  86.     abs->makeDrink();
  88. }
  90. void test01()
  91. {
  92.     //制作咖啡
  93.     doWork(new Coffee);
  95.     cout << "-----------" << endl;
  97.     doWork(new Tea);
  99. }
  101. int main() {
  103.     test01();
  105.     system("pause");
  107.     return 0;
  108. }

虚析构与纯虚析构

多态使用时，如果子类中有属性开辟到堆区，那么父类指针在释放时无法调用到子类的析构代码
解决方式：将父类中的析构函数改为虚析构或者**
虚析构和纯虚析构共性：

  • 可以解决父类指针释放子类对象
  • 都需要有具体的函数实现

虚析构和纯虚析构区别：

  • 如果是纯虚析构，该类属于抽象类，无法实例化对象

虚析构语法：
virtual ~类名(){}
纯虚析构语法：
virtual ~类名() = 0;
类名::~类名(){}

  1. #include<iostream>
  2. #include<string>
  3. using namespace std;
  5. //虚析构与纯虚析构
  6. class Animal {
  7. public:
  9.     Animal()
  10.     {
  11.         cout << "Animal 构造函数调用！" << endl;
  12.     }
  13.     virtual void Speak() = 0;
  15.     //析构函数加上virtual关键字，变成虚析构函数
  16.     //virtual ~Animal()
  17.     //{
  18.     //    cout << "Animal虚析构函数调用！" << endl;
  19.     //}
  21.     virtual ~Animal() = 0;  ///纯虚析构
  22. };
  24. Animal::~Animal()
  25. {
  26.     cout << "Animal 纯虚析构函数调用！" << endl;
  27. }
  29. //和包含普通纯虚函数的类一样，包含了纯虚析构函数的类也是一个抽象类。不能够被实例化。
  31. class Cat : public Animal {
  32. public:
  33.     Cat(string name)
  34.     {
  35.         cout << "Cat构造函数调用！" << endl;
  36.         m_Name = new string(name);
  37.     }
  38.     virtual void Speak()
  39.     {
  40.         cout << *m_Name << "小猫在说话!" << endl;
  41.     }
  42.     ~Cat()
  43.     {
  44.         cout << "Cat析构函数调用!" << endl;
  45.         if (this->m_Name != NULL) {
  46.             delete m_Name;
  47.             m_Name = NULL;
  48.         }
  49.     }
  51. public:
  52.     string* m_Name;
  53. };
  55. void test01()
  56. {
  57.     Animal* animal = new Cat("Tom");
  58.     animal->Speak();
  60.     //通过父类指针去释放，会导致子类对象可能清理不干净，造成内存泄漏
  61.     //怎么解决？给基类增加一个虚析构函数
  62.     //虚析构函数就是用来解决通过父类指针释放子类对象
  63.     delete animal;
  64. }
  66. int main() {
  68.     test01();
  70.     system("pause");
  72.     return 0;
  73. }

总结：
1. 虚析构或纯虚析构就是用来解决通过父类指针释放子类对象
2. 如果子类中没有堆区数据，可以不写为虚析构或纯虚析构
3. 拥有纯虚析构函数的类也属于抽象类

案列三

电脑主要组成部件为 CPU（用于计算），显卡（用于显示），内存条（用于存储）
将每个零件封装出抽象基类，并且提供不同的厂商生产不同的零件，例如Intel厂商和Lenovo厂商
创建电脑类提供让电脑工作的函数，并且调用每个零件工作的接口
测试时组装三台不同的电脑进行工作。

  1. #include<iostream>
  2. #include<string>
  3. #include<vector>
  4. using namespace std;
  6. //抽象不同的类
  8. class CPU
  9. {
  10. public:
  11.     virtual void calculate() = 0;
  13. };
  15. class VideoCard
  16. {
  17. public:
  18.     virtual void display() = 0;
  19. };
  21. class Memory
  22. {
  23. public:
  24.     virtual void storage() = 0;
  25. };
  27. class Computer
  28. {
  29. public:
  30.     Computer(CPU* cpu, VideoCard* vc, Memory* mem)
  31.     {
  32.         m_cpu = cpu;
  33.         m_vc = vc;
  34.         m_mem = mem;    
  35.     }
  36.     //提供工作函数
  37.     void work()
  38.     {
  39.         //让零件工作起来
  40.         m_cpu->calculate();
  42.         m_vc->display();
  44.         m_mem->storage();
  46.     }
  48.     //提供析构函数 释放3各电脑零件
  49.     ~Computer()
  50.     {
  51.         if (m_cpu != NULL)
  52.         {
  53.             delete m_cpu;
  54.             m_cpu = NULL;
  55.         }
  56.         if (m_vc != NULL)
  57.         {
  58.             delete m_vc;
  59.             m_vc = NULL;
  60.         }
  61.         if (m_mem != NULL)
  62.         {
  63.             delete m_mem;
  64.             m_mem = NULL;
  65.         }
  67.     }
  69. private:
  70.     CPU* m_cpu;        //CPU的指针
  71.     VideoCard* m_vc;   //显卡的指针
  72.     Memory* m_mem;     //内存的指针
  75. };
  76. //具体厂商
  77. //Intel厂商
  78. class IntelCPU : public CPU
  79. {
  80. public:
  81.     virtual void calculate()
  82.     {
  83.         cout << "Intel的CPU开始计算了！" << endl;
  84.     }
  85. };
  87. class IntelVideoCard : public VideoCard
  88. {
  89. public:
  90.     virtual void display()
  91.     {
  92.         cout << "Intel的显卡开始显示了！" << endl;
  93.     }
  94. };
  96. class IntelMemory : public Memory
  97. {
  98. public:
  99.     virtual void storage()
  100.     {
  101.         cout << "Intel的内存开始存储了！" << endl;
  102.     }
  103. };
  105. //Lenovo厂商
  106. class LenovoCPU : public CPU
  107. {
  108. public:
  109.     virtual void calculate()
  110.     {
  111.         cout << "ILenovo的CPU开始计算了！" << endl;
  112.     }
  113. };
  115. class LenovoVideoCard : public VideoCard
  116. {
  117. public:
  118.     virtual void display()
  119.     {
  120.         cout << "Lenovo的显卡开始显示了！" << endl;
  121.     }
  122. };
  124. class LenovoMemory : public Memory
  125. {
  126. public:
  127.     virtual void storage()
  128.     {
  129.         cout << "Lenovo的内存开始存储了！" << endl;
  130.     }
  131. };
  133. void test01()
  134. {
  135.     //第一台电脑零件
  136.     CPU* intelcpu = new IntelCPU;
  137.     VideoCard* intelCard = new IntelVideoCard;
  138.     Memory* intelMem = new IntelMemory;
  139.     //创建第一台电脑
  140.     Computer* computer1 = new Computer(intelcpu, intelCard, intelMem);
  141.     computer1->work();
  142.     delete computer1;
  144.     cout << "-------------------------------" << endl;
  145.     cout << "第二台电脑开始工作" << endl;
  147.     //创建第二台电脑
  148.     Computer* computer2 = new Computer(new LenovoCPU, new LenovoVideoCard,new LenovoMemory);
  149.     computer2->work();
  150.     delete computer2;
  152.     cout << "-------------------------------" << endl;
  153.     cout << "第三台电脑开始工作" << endl;
  155.     //创建第三台电脑
  156.     Computer* computer3 = new Computer(new LenovoCPU, new IntelVideoCard, new LenovoMemory);
  157.     computer3->work();
  158.     delete computer3;
  159. }
  161. int main()
  162. {
  163.     test01();
  165.     system("pause");
  167.     return 0;
  169. }

文件操作

文本文件

写文件

写文件步骤如下：

  1. 包含头文件
    #include
  2. 创建流对象
    ofstream ofs;
  3. 打开文件
    ofs.open(“文件路径”,打开方式);
  4. 写数据
    ofs << “写入的数据”;
  5. 关闭文件
    ofs.close();

文件打开方式：

打开方式 解释
ios::in 为读文件而打开文件
ios::out 为写文件而打开文件
ios::ate 初始位置：文件尾
ios::app 追加方式写文件
ios::trunc 如果文件存在先删除，再创建
ios::binary 二进制方式

注意： 文件打开方式可以配合使用，利用|操作符
例如：用二进制方式写文件 **ios::binary | ios:: out**
示例：

  1. #include<iostream>
  2. #include <fstream>
  3. using namespace std;
  5. void test01()
  6. {
  7.     //1、包含头文件 fstream
  8.     //2、创建流对象
  9.     ofstream ofs;
  10.     //3、指定打开方式
  11.     ofs.open("test.txt", ios::out);
  12.     //4、写文件
  13.     ofs << "姓名：张三" << endl;
  14.     ofs << "性别：男" << endl;
  15.     ofs << "年龄：18" << endl;
  16.     //5、关闭文件
  17.     ofs.close();
  18. }
  20. int main() {
  22.     test01();
  24.     system("pause");
  26.     return 0;
  27. }

总结：

  • 文件操作必须包含头文件 fstream
  • 读文件可以利用 ofstream ，或者fstream类
  • 打开文件时候需要指定操作文件的路径，以及打开方式
  • 利用<<可以向文件中写数据
  • 操作完毕，要关闭文件

    读文件

    读文件与写文件步骤相似，但是读取方式相对于比较多
    读文件步骤如下：
  1. 包含头文件
    #include
  2. 创建流对象
    ifstream ifs;
  3. 打开文件并判断文件是否打开成功
    ifs.open(“文件路径”,打开方式);
  4. 读数据
    四种方式读取
  5. 关闭文件
    ifs.close();

示例：

  1. #include <fstream>
  2. #include <string>
  3. void test01()
  4. {
  5.     //1、包含头文件
  6.     //2、创建流对象
  7.     ifstream ifs;
  8.     //3、打开文件，并且判断是否打开成功
  9.     ifs.open("test.txt", ios::in);
  10.     //4、判断是否打开成功
  11.     if (!ifs.is_open())
  12.     {
  13.         cout << "文件打开失败" << endl;
  14.         return;
  15.     }
  16.     //5、读文件
  17.     //第一种方式
  18.     //char buf[1024] = { 0 };
  19.     //while (ifs >> buf)
  20.     //{
  21.     //    cout << buf << endl;
  22.     //}
  24.     //第二种
  25.     //char buf[1024] = { 0 };
  26.     //while (ifs.getline(buf,sizeof(buf)))
  27.     //{
  28.     //    cout << buf << endl;
  29.     //}
  31.     //第三种
  32.     string buf;
  33.     while (getline(ifs, buf))
  34.     {
  35.         cout << buf << endl;
  36.     }
  38.     //第四种（不推荐）
  39.     //char c;
  40.     //while ((c = ifs.get()) != EOF)
  41.     //{
  42.     //    cout << c;
  43.     //}
  44.     //6、关闭文件
  45.     ifs.close();
  46. }
  48. int main() {
  50.     test01();
  52.     system("pause");
  54.     return 0;
  55. }

总结：

  • 读文件可以利用 ifstream ，或者fstream类
  • 利用is_open函数可以判断文件是否打开成功
  • close 关闭文件

    二进制文件（？）

    写文件

    二进制方式写文件主要利用流对象调用成员函数write
    函数原型 ：ostream& write(const char * buffer,int len);
    参数解释：字符指针buffer指向内存中一段存储空间。len是读写的字节数
    示例： ```c

    include

    include

    include

    using namespace std;

class Person { public: char m_Name[64]; int m_Age; };

//二进制文件 写文件 void test01() { //1、包含头文件

  1. //2、创建输出流对象
  2. ofstream ofs("person.txt", ios::out | ios::binary);
  4. //3、打开文件
  5. //ofs.open("person.txt", ios::out | ios::binary);
  7. Person p = { "张三"  , 18 };
  9. //4、写文件
  10. ofs.write((const char*)&p, sizeof(p));
  12. //5、关闭文件
  13. ofs.close();

}

int main() {

  1. test01();
  3. system("pause");
  5. return 0;

}

  1. 总结：
  3. - 文件输出流对象 可以通过write函数，以二进制方式写数据
  4. <a name="G27si"></a>
  5. #### 读文件
  6. 二进制方式读文件主要利用流对象调用成员函数read<br />函数原型：`istream& read(char *buffer,int len);`<br />参数解释：字符指针buffer指向内存中一段存储空间。len是读写的字节数<br />示例：
  7. ```c
  8. #include<iostream>
  9. #include <fstream>
  10. #include <string>
  11. using namespace std;
  13. class Person
  14. {
  15. public:
  16.     char m_Name[64];
  17.     int m_Age;
  18. };
  19. //二进制文件 读文件
  20. void test01()
  21. {
  22.     //1、包含头文件
  23.     //2、创建流文件
  24.     ifstream ifs("person.txt", ios::in | ios::binary);
  25.     //3、判断文件是否打开成功
  26.     if (!ifs.is_open())
  27.     {
  28.         cout << "文件打开失败" << endl;
  29.     }
  30.     //4、读文件
  31.     Person p;
  32.     ifs.read((char*)&p, sizeof(p));
  34.     cout << "姓名： " << p.m_Name << " 年龄： " << p.m_Age << endl;
  35.     //5、关闭文件
  36.     ifs.close();
  37. }
  39. int main() {
  41.     test01();
  43.     system("pause");
  45.     return 0;
  46. }

  • 文件输入流对象 可以通过read函数，以二进制方式读数据

    项目实战——职工管理系统

    管理系统需求

    创建管理类

  • 与用户交互

  • 对职工增删改查的操作
  • 与文件的读写交互

    菜单功能

    添加成员函数

退出功能

提供接口功能

创建职工类

  • 职工类
  • 经理类

  • 老板类

    添加职工

    功能描述：批量添加职工，并且保存到文件中

    文件交互-写文件（？写文件时总是报错访问冲突）

    添加一个文件，保存职工信息

    文件交互-读文件

  • 文件不存在

  • 文件存在，但为空

在workerManager.cpp中的构造函数追加代码：

  1.     //文件存在，并且没有记录
  2.     char ch;
  3.     ifs >> ch;
  4.     if (ifs.eof())
  5.     {
  6.         cout << "文件为空!" << endl;
  7.         this->m_EmpNum = 0;
  8.         this->m_FileIsEmpty = true;
  9.         this->m_EmpArray = NULL;
  10.         ifs.close();
  11.         return;
  12.     }

追加代码位置如图：
将文件创建后清空文件内容，并测试该情况下初始化功能
我们发现文件不存在或者为空清空 m_FileIsEmpty 判断文件是否为空的标志都为真，那何时为假？
成功添加职工后，应该更改文件不为空的标志
在void WorkerManager::Add_Emp()成员函数中添加：

  1.         //更新职工不为空标志
  2.         this->m_FileIsEmpty = false;
  • 文件存在且保存职工数据

在workerManager.h中添加成员函数 int get_EmpNum();

  1.     //统计人数
  2.     int get_EmpNum();

workerManager.cpp中实现

  1. int WorkerManager::get_EmpNum()
  2. {
  3.     ifstream ifs;
  4.     ifs.open(FILENAME, ios::in);
  6.     int id;
  7.     string name;
  8.     int dId;
  10.     int num = 0;
  12.     while (ifs >> id && ifs >> name && ifs >> dId)
  13.     {
  14.         //记录人数
  15.         num++;
  16.     }
  17.     ifs.close();
  19.     return num;
  20. }

在workerManager.cpp构造函数中继续追加代码：

  1.     int num =  this->get_EmpNum();
  2.     cout << "职工个数为：" << num << endl;  //测试代码
  3.     this->m_EmpNum = num;  //更新成员属性

手动添加一些职工数据，测试获取职工数量函数
初始化数组
根据职工的数据以及职工数据，初始化workerManager中的Worker ** m_EmpArray 指针
在WorkerManager.h中添加成员函数 void init_Emp();

  1.     //初始化员工
  2.     void init_Emp();

在WorkerManager.cpp中实现

  1. void WorkerManager::init_Emp()
  2. {
  3.     ifstream ifs;
  4.     ifs.open(FILENAME, ios::in);
  6.     int id;
  7.     string name;
  8.     int dId;
  10.     int index = 0;
  11.     while (ifs >> id && ifs >> name && ifs >> dId)
  12.     {
  13.         Worker * worker = NULL;
  14.         //根据不同的部门Id创建不同对象
  15.         if (dId == 1)  // 1普通员工
  16.         {
  17.             worker = new Employee(id, name, dId);
  18.         }
  19.         else if (dId == 2) //2经理
  20.         {
  21.             worker = new Manager(id, name, dId);
  22.         }
  23.         else //总裁
  24.         {
  25.             worker = new Boss(id, name, dId);
  26.         }
  27.         //存放在数组中
  28.         this->m_EmpArray[index] = worker;
  29.         index++;
  30.     }
  31. }

在workerManager.cpp构造函数中追加代码

  1.     //根据职工数创建数组
  2.     this->m_EmpArray = new Worker *[this->m_EmpNum];
  3.     //初始化职工
  4.     init_Emp();
  6.     //测试代码
  7.     for (int i = 0; i < m_EmpNum; i++)
  8.     {
  9.         cout << "职工号： " << this->m_EmpArray[i]->m_Id
  10.             << " 职工姓名： " << this->m_EmpArray[i]->m_Name
  11.             << " 部门编号： " << this->m_EmpArray[i]->m_DeptId << endl;
  12.     }

运行程序，测试从文件中获取的数据
至此初始化数据功能完毕，测试代码可以注释或删除掉！

显示职工

完成显示职工和删除职工视频学习，还未动手操作

模板

模板概念

函数模板

函数模板语法

函数模板注意事项

普通函数与函数的

类模板

类模板语法

STL（标准模板库）初识

STL基本概念

  • STL(Standard Template Library,标准模板库)
  • STL 从广义上分为: 容器(container) 算法(algorithm) 迭代器(iterator)
  • 容器和算法之间通过迭代器进行无缝连接。
  • STL 几乎所有的代码都采用了模板类或者模板函数

    STL六大组件

    STL大体分为六大组件，分别是:容器、算法、迭代器、仿函数、适配器（配接器）、空间配置器
  1. 容器：各种数据结构，如vector、list、deque、set、map等,用来存放数据。
  2. 算法：各种常用的算法，如sort、find、copy、for_each等
  3. 迭代器：扮演了容器与算法之间的胶合剂。
  4. 仿函数：行为类似函数，可作为算法的某种策略。
  5. 适配器：一种用来修饰容器或者仿函数或迭代器接口的东西。
  6. 空间配置器：负责空间的配置与管理