B站黑马C++内容，自己手动敲了一遍代码，文章之间也加入了一些我个人的理解，仅供学习和参考用，程序代码均来自黑马程序员 。

一.C++基础入门

1.1第一个c++程序 （输出一个hello world）

#include<iostream>
using namespace std;int main()
{cout << "hello world" << endl;system("pause");return 0;
}

这里我们要知道cout<<""<<endl; 我们只要在双引号""里输入任意的内容，就会在控制台上打印相应的内容就可以了，其它行的代码可以理解为一个默认的框架，我们每次写的时候要加上这几行代码，不然就无法正常执行程序。后面会详细介绍的。

1.2注释

作用：在代码中加一些说明和解释，方便自己或者其他程序员阅读代码

两种格式

1.单行注释：//描述信息

通常在一行代码的上方，或者一条语句的末尾，对改代码进行说明

2.多行注释：/* 描述信息 */

通常在一段代码的上方，对该代码进做整体的说明

#include<iostream>
using namespace std;int main()
{cout << "你好" << endl;//cout<<"hello"<<endl;/*cout<<"hi"<<endl;cout<<"haha"<<endl;*/system("pause");return 0;
}

上图控制台输出的结果是 "你好" 不会输出"hello" "hi" 以及 "haha"，是因为给它们加了注释，注释可以理解为是给程序员看的，而编译器不会执行里面的程序代码。

1.3变量

作用：给一段指定的内存空间起名，方便操作这段内存

语法：数据类型 变量名 = 初始值；

#include<iostream>
using namespace std;int main()
{int a = 10;cout << "a = " << a << endl;system("pause");return 0;
}

1.4常量

作用：记录程序中不可更改的数据

C++定义常量两种方式

1.#define宏常量： #define 常量名 常量值

通常在文件上方定义，表示一个常量

const 修饰的变量 const数据类型 常量名 = 常量值

通常在变量定义前加关键字const，修饰该变量为常量，不可更改

#include<iostream>
using namespace std;
#define Day 7
int main()
{//1.#define定义宏常量cout << "一周一共有" << Day << "天" << endl;//2.const修饰的变量const int a = 10;// a = 20; 此时会报错，因为a已近被const修饰了，成为了一个常量，所以不可以改变             cout << "a = " << a << endl;system("pause");return 0;
}

1.5关键字

作用：C++中预先保留的单词

在定义变量或者常量的时候，不要用关键字

int int = 10；（错误，这里的第一个是int是关键字，第二个是数据类型，不能和关键字一样）

1.6标识符的命名规则

作用：C++中规定给标识符(变量、常量)命名时，有一套自己的规则

1.标识符不能是关键字

2.标识符只能由字母、数字、下划线组成。

3.第一个字符必须为字母或者下划线

4.标识符中字母区分大小写

int abc=10；

int _abc=20;

int _123abc=32;

int 234abc=43;(错误，不能以数字开头)

二.数据类型

C++规定在创建一个变量或者常量时，必须要指定相应的数据类型，否则无法给变量分配内存

2.1整形

作用：整形变量表示的是整形数据类型

C++中能够表示类型的数据类型有以下几种方式，区别在于所占内存空间的不同：

#include<iostream>
using namespace std;
int main()
{//1.短整型shortshort num1 = 10;cout << "short(num1)所占内存空间的大小为：" << sizeof(short) << endl;cout << "short(num1)所占内存空间的大小为：" << sizeof(num1) << endl;//2.整型intint num2 = 10;cout << "int(num2)所占内存空间的大小为：" << sizeof(int) << endl;cout << "int(num2)所占内存空间的大小为：" << sizeof(num2) << endl;//3.长整型longlong num3 = 10;cout << "long(num3)所占内存空间的大小为：" << sizeof(long) << endl;cout << "long(num3)所占内存空间的大小为：" << sizeof(num3) << endl;//4.长长整型long longlong long num4 = 10;cout << "long long(num4)所占内存空间的大小为：" << sizeof(long long) << endl;cout << "long long(num4)所占内存空间的大小为：" << sizeof(num4) << endl;cout << "num1= " << num1 << endl;cout << "num2= " << num2 << endl;cout << "num3= " << num3 << endl;cout << "num4= " << num4 << endl;system("pause");return 0;
}

2.2sizeof关键字

作用：利用sizeof关键字可以统计数据类型所占内存空间的大小

语法：sizeof（数据类型/变量）

2.3实型（浮点型）

作用：用于表示小数

浮点型变量分为两种：

1. 单精度float

1. 双精度double

两者的区别在于表示数字有效范围不同

3.14表示的是三位有效数字

#include<iostream>
using namespace std;
int main()
{//1、单精度 floatfloat f1 = 3.1415926f;cout << "f1= " << f1 << endl;//2、双精度 doubledouble f2 = 3.14;cout << "f2= " << f2 << endl;//统计float和doubel所占的内存空间cout << "float所占用的内从空间为" << sizeof(float) << endl;cout << "double所占用的内从空间为" << sizeof(double) << endl;//科学计数法//3e2表示3x10的平方，3e-3表示3x10的负2次方float f3 = 3e2;cout << "f3= " << f3 << endl;float f4 = 3e-2;cout << "f4= " << f4 << endl;system("pause");return 0;
}

2.4字符型

#include<iostream>
using namespace std;
int main()
{//字符型变量创建方式char ch = 'a';cout << ch << endl;//字符型变量所占内存空间的的大小cout << "char所占内存空间的大小为：" << sizeof(char) << endl;//字符型变量常见的错误//char ch2 = "b";           不能用双引号//char ch3 = 'abcdef';      创建字符型变量单引号中智能存在一个值//字符型变量对应的ASCII码值//a-97   b-98  A-65(以此类推)cout << (int)ch << endl;           //结果为97system("pause");return 0;
}

*C和C++中字符型变量只占一个字节

*字符型变量并不是把字符本身放到内存中存储，而是将对应的ASC11码值放到存储单元。

2.5转义字符

作用：用于表示一些不能显示出来的ASC11字符

现阶段我们常用的转义字符有\n \\ \t

#include<iostream>
using namespace std;
int main()
{//转义字符//换行符   \ncout << "hello world\n";//反斜杠   \\cout << "\\" << endl;   //输出两个\\表示一个\//水平制表符  \t   有对齐效果，看起来比较整洁cout << "aaa\thelloworld" << endl;cout << "aaaaa\thelloworld" << endl;cout << "a\thelloworld" << endl;system("pause");return 0;
}

2.6字符串类型

#include<iostream>
using namespace std;
#include<String>        //用C++风格字符串，要包含这个头文件
int main()
{//1.C风格字符串//注意事项   char 字符串名[]//等号后面要用双引号 包含起来字符串char str[] = "hello world";cout << str << endl;//2.C++风格字符串string str2 = "hello world";cout << str2 << endl;system("pause");return 0;
}

2.7布尔类型bool

作用：布尔类型代表真或者假的值

Bool类型只有两个值：

*true-----真（本质是1）

*false----假（本质是0）

Bool类型占一个字节大小

#include<iostream>
using namespace std;
int main()
{//1.创建bool数据类型bool flag = true;  //true代表真cout << flag << endl;        //1flag = false;cout << flag << endl;        //0//2.查看bool类型所占内存空间的大小cout << "布尔类型所占内存空间的大小为：" << sizeof(bool) << endl;  //1system("pause");return 0;
}

2.8数据的输入

作用：用于从键盘获取数据

关键字：sin

语法 cin>>变量

#include<iostream>
using namespace std;
int main()
{cout << "请随机输入一个数字" << endl;int a;cin >> a;cout << "输入的数为：" << a << endl;system("pause");return 0;
}

三.运算符

作用：用于执行代码的运算

3.1算数运算符

作用：用于处理四则运算

算数运算符包括以下符号：

#include<iostream>
using namespace std;
int main()
{//加减乘除int a1 = 10;int b1 = 3;cout << "a + b = " << a1 + b1 << endl;   //13cout << "a - b = " << a1 - b1 << endl;   //7cout << "a * b = " << a1 * b1 << endl;   //30cout << "a / b = " << a1 / b1 << endl;   //3  两个整数相除，结果依然是整数，将小数部分去除//两个小数部分相除，除数不可以是0//两个小数之间可以相除，运算的结果也可以是小数//取余运算//两个小数是不可以取模运算的int a2 = 10;int b2 = 3;cout << "a2 % b2 = " << a2 % b2 << endl;   //1//前置递增int a = 10;++a;       //让变量加一cout << "a = " << a << endl;       //11//后置递增int b = 10;b++;      //让变量加一cout << "b = " << b << endl;       //11//前置和后置的区别//前置递增，先让变量+1，然后进行表达式的运算int a4 = 5;int b4 = ++a4 * 10;cout << "a4 = " << a4 << endl;       //6cout << "b4 = " << b4 << endl;       //60int a5 = 5;int b5 = a5++ * 10;cout << "a5 = " << a5 << endl;      //6cout << "b5 = " << b5 << endl;      //50system("pause");return 0;
}

3.2赋值运算符

作用：用于将表达式的值赋给变量

赋值运算符包括以下几个符号

#include<iostream>
using namespace std;int main()
{//赋值运算符// +=int a = 10;a += 2;cout << "a = " << a << endl;    //12// -=a = 10;a -= 2;cout << "a = " << a << endl;   //8// *=a = 10;a *= 2;cout << "a = " << a << endl;   //20// /=a = 10;a /= 2;cout << "a = " << a << endl;    //5system("pause");return 0;
}

3.3比较运算符

作用：用于表达式的比较，并返回一个真值或假值

比较运算符有以下符号：

#include<iostream>
using namespace std;int main()
{//比较运算符int a = 10;int b = 20;// ==cout << (a == b) << endl;   //0// !=cout << (a != b) << endl;   //1// >cout << (a > b) << endl;    //0// <cout << (a < b) << endl;    //1// >=cout << (a >= b) << endl;   //0// <=cout << (a <= b) << endl;   //1system("pause");return 0;
}

3.4逻辑运算符

作用：用于根据逻辑表达式的值返回真值或假值

逻辑运算符有以下符号：

#include<iostream>
using namespace std;int main()
{//逻辑运算符 非int a = 10;//在c++中除了0 都为真cout << !a << endl;        //0cout << !!a << endl;       //1//逻辑运算符  与//同真为真，其余为假，零零为假int b = 10;int c = 10;cout << (b && c) << endl;    //1b = 0;c = 10;cout << (b && c) << endl;   //0b = 0;c = 0;cout << (b && c) << endl;   //0//逻辑运算符  或//同假为假，其余为真int d = 10;int e = 10;cout << (d || e) << endl;   //1d = 0;e = 10;cout << (d || e) << endl;   //1d = 0;e = 0;cout << (d || e) << endl;   //0system("pause");return 0;
}

四.程序流程结构

C/C++支持最基本的三种程序运行结构：顺序结构、选择结构、循环结构。

顺序结构：程序按照顺序执行，不发生跳转。

选择结构：依据条件是否满足，有选择的执行相应的功能。

循环结构：依据条件是否满足，循环多次执行某段代码。

4.1选择结构

if语句

作用：执行满足条件的语句

If语句的三种表现形式

单行格式if语句

多行格式if语句

多条件的if语句

1. 单行格式if语句：if（条件）{条件满足执行的语句}

#include<iostream>
using namespace std;
int main()
{//选择结构 单行if语句//用户输入分数，如果分数大于600，视为考上一本大学，在屏幕上输出//1、用户输入分数int score = 0;cout << "请输入一个分数" << endl;cin >> score;//2、打印用户输入的分手cout << "您输入的分数为 " << score << endl;//3、判断分数是否大于600，如果大于，那么输出//注意事项，if条件后不要加分号  ；if (score > 600){cout << "恭喜你考入一本大学" << endl;}system("pause");return 0;
}

1. 多行格式if语句：if（条件）{条件满足执行的预计}else{条件不满足执行的语句}

1. 多条件的if语句：if 于 else多次使用

#include<iostream>
using namespace std;
int main()
{//选择结构  多条件if语句//输入一个考试分数，如果大于600，那么考上一本大学。//大于500，视为考上二本大学。//大与400，视为考上三本大学。//小于等于400，则未考上大学，在屏幕上输出。//1、输入你所考的分数int score = 0;cout << "请输入您的高考分数" << endl;cin >> score;//2、提示用户所输入的分数cout << "您的高考分数为 " << score << endl;//3、判断分数所能上的大学，给出最终结果if (score >= 600){cout << "恭喜您考入一本大学" << endl;}else if (score >= 500){cout << "恭喜您考入二本大学" << endl;}else if (score >= 400){cout << "恭喜您考入三本大学" << endl;}else {cout << "未考上大学" << endl;}system("pause");return 0;
}

嵌套if语句：在if语句中，可以嵌套使用if语句，达到更清晰的条件判断。

案例需求：

提示用户输入一个高考考试分数，根据分数做出以下判断

1.分数如果大于600分视为考上一本大学，大于500分考上而二本大学，大于400考上三本大学，其余均视为未考上本科大学

2.在一本分数中，如果大于700分，考入北大，大于650分，考入清华，大于600考入人大。

if (score >= 600){if (score >= 700){cout << "您能考入北京大学" << endl;}else if (score >= 650){cout << "您能考入清华大学" << endl;}else{cout << "您能考入中国人民大学" << endl;}}

练习案例：

有三只小猪ABC，分别输入三只小猪的体重，并且判断哪只小猪最重

#include<iostream>
using namespace std;
int main()
{int a, b, c;cout << "小猪a的重量为" << endl;cin >> a;cout << "小猪b的重量为" << endl;cin >> b;cout << "小猪c的重量为" << endl;cin >> c;if (a > b){if (a > c){cout << "小猪a最重" << endl;}else{cout << "小猪c最重" << endl;}}if (b > a){if (b > c){cout << "小猪b最重" << endl;}else{cout << "小猪c最重" << endl;}}system("pause");return 0;
}

三目运算符

作用：通过三目运算符实现简单的判断

语法：表达式1？表达式2：表达式3

解释：

如果表达式1的值为真，执行表达式2，并返回表达式2的结果；

如果表达式1的值为假，执行表达式3，并返回表达式3的结果；

#include<iostream>
using namespace std;
int main()
{//三目运算符//创建三个变量a,b,c//将a和b做比较，将变量大的值赋给变量cint a = 10;int b = 20;int c = 0;c = (a > b ? a : b);cout << "c= " << c << endl;  //c=20//在C++中三目运算符返回的是变量，可以继续赋值。(a > b ? a : b) = 100;cout << "a= " << a << endl;  //a=10cout << "b= " << b << endl;  //b=100system("pause");return 0;
}

switch语句

作用：执行多条件分支语句

语法：

switch(表达式)

{

case 结果1：执行语句；break；

case 结果2：执行语句；break；

.........

default:执行语句；break；

}

#include<iostream>
using namespace std;
int main()
{//switch 语句//给电影进行打分//10~9    经典//8~7     非常好//6~5     一般//5以下   烂片//1、提示用户给电影评分cout << "请您给这部电影打分" << endl;//2、用户开始进行打分int score = 0;cin >> score;cout << "您给这部电影打的分数为" << score << endl;//3、根据用户所给的分数提示用户最后的结果switch (score){case 10:cout << "您认为是经典电影" << endl;break;  //退出当前的分支case 9:cout << "您认为是经典电影" << endl;break;case 8:cout << "您认为是电影非常好" << endl;break;case 7:cout << "您认为是电影非常好" << endl;break;case 6:cout << "您认为是电影一般" << endl;break;case 5:cout << "您认为是电影一般" << endl;break;default:cout << "您认为是烂片" << endl;}system("pause");return 0;
}

4.2循环结构

while循环语句

作用：满足循环条件，执行循环语句

语法：while（循环条件）{循环语句}

解释：只有循环条件的结果为真，就执行循环语句

#include<iostream>
using namespace std;
int main()
{//while循环//在屏幕中打印0~9这十个数字//在循环中，避免死循环的出现int num1 = 0;while (num1 < 10)//如果括号里为1，那么程序将永远执行下去{cout << num1 << endl;num1++;}system("pause");return 0;

While循环案例练习：

案例描述：系统随机生成1到100之间的数字，玩家进行猜测，如果猜错，提示玩家数字过大或者过小，如果猜对恭喜玩家胜利，并且推出游戏。

#include<iostream>
using namespace std;
//time系统时间头文件包含
#include<ctime>
int main()
{//添加随机数种子  作用利用当前系统时间生成随机数，防止每次随机数都一样srand((unsigned int)time(NULL));//这是一个伪随机数的生成//1、系统生成随机数int num = rand() % 100 + 1;   //rand()%100+1 生成一个0+1~99+1的随机数//cout << num << endl;   //2、玩家进行猜测int val = 0;     //玩家输入的随机数while (1){cin >> val;//3、判断玩家的猜想if (val > num){cout << "猜测过大" << endl;}else if (val < num){cout << "猜测过小" << endl;}else{cout << "恭喜你猜对了" << endl;break;//可以利用这个关键字退出当前循环}}//猜对    退出游戏//猜错    提示猜的结果  过大或者过小  重新返回第二步system("pause");return 0;
}

do.......while循环语句

作用：do{循环语句}while{循环语句}

注意：与while的区别在于do....while会先执行一次循环语句，在判断循环条件

#include<iostream>
using namespace std;
int main()
{//do.....while循环语句//在屏幕中输出0-9这十个数字int num1 = 0;do{cout << num1 << endl;num1++;} while (num1 < 10);//do...while与while循环的区别在于do....while会先执行一次循环语句system("pause");return 0;
}

案例练习：水仙花数

案例描述：水仙花数是一个三位数，他的每个位上的三次幂之和等于他本身

例如：1^3+5^3+3^3=153

请利用do.....while语句，求出所有三位数中的水仙花数

#include<iostream>
using namespace std;
int main()
{int a = 100;while (a < 1000){int ge = a % 10;int shi = a / 10 % 10;int bai = a / 100;if (ge* ge* ge + shi * shi * shi + bai * bai * bai == a){cout << a << endl;}a++;}system("pause");return 0;
}

for循环语句

作用：满足循环条件，执行循环语句

语法：for(起始表达式;条件表达式;末尾循环体;}{循环语句}

#include<iostream>
using namespace std;
int main()
{//for循环，从数字0打印到数字9for (int i = 0; i < 10; i++){cout << i << endl;}system("pause");return 0;
}

练习案例：敲桌子

案例描述：从1开始数到数字100，如果个位数字含有7，或者十位数字含有7，或者该数字是7的倍数，我们打印敲桌子，其余数字直接打印输出

#include<iostream>
using namespace std;
int main()
{for (int i = 1; i <= 100; i++){if (i % 10 == 0){cout << "敲桌子" << endl;}if (i / 10 == 7){cout << "敲桌子" << endl;}if (i % 7 == 0){cout << "敲桌子" << endl;}else{cout << i << endl;}}system("pause");return 0;
}

嵌套循环

作用：在循环体中再嵌套一层循环，解决一些实际问题

例如我们想在屏幕中打印图片，就是要利用嵌套循环

#include<iostream>
using namespace std;
int main()
{//利用嵌套循环实现星图//打印一行星图//外层循环一次，内层循环一周//外层循环for (int j = 0; j < 10; j++){//内层循环for (int i = 0; i < 10; i++){cout << "* ";}cout << endl;}system("pause");return 0;
}

案例练习：乘法口诀表

案例描述：利用嵌套循环，实现九九乘法表

#include<iostream>
using namespace std;
int main()
{//乘法口诀表//打印行数for (int i = 1; i <= 9; i++){//cout << i << endl;for (int j = 1; j<=i; j++){cout << j << " * " << i << " = " << j * i<<"   " ;}cout << endl;}system("pause");return 0;
}

4.3跳跃语句

break语句

作用：用于跳出选择结构或者循环结构

Break使用的动机：

出现在switch条件语句中，作用是终止case并跳出switch

出现在循环语句中，作用是跳出当前循环

出现在嵌套语句中，跳出最近的内层循环语句

#include<iostream>
using namespace std;
int main()
{//break的使用时机//1、出现在switch语句中//cout << "请选择副本的难度" << endl;//cout << "1、普通" << endl;//cout << "2、中等" << endl;//cout << "3、困难" << endl;//int select = 0;     // 创建选择结果的变量//cin >> select;//switch (select)//{//case 1://    cout << "您选择的是普通难度" << endl;//    break;//退出switch语句//case 2://    cout << "您选择的是中等难度" << endl;//    break;//case 3://    cout << "您选择的是困难难度" << endl;//    break;//default://    break;//}//2、出现在循环语句中/*for (int i = 0; i < 10; i++){if (i > 5){break;}cout << i << endl;}*///3、出现在嵌套循环语句中for (int j = 0; j < 10; j++){for (int i = 0; i < 10; i++){if (i == 5){break;}cout << "* ";}cout << endl;}system("pause");return 0;
}

continue语句

作用：在循环语句中，跳过本次循环中余下尚未执行的语句，继续执行下一次循环

#include<iostream>
using namespace std;
int main()
{for (int i = 0; i <= 100; i++){//如果是奇数输出，偶数不输出if (i % 2 == 0){continue;//break会退出循环，continue不会，他会执行下一次循环}cout << i << endl;}system("pause");return 0;
}

goto 语句

作用：可以无条件的跳转语句

语法：goto标记

解释：如果标记的名称存在，执行到goto语句值，会跳转的标记的位置

#include<iostream>
using namespace std;
int main()
{//goto过于强大，不推荐使用  知道就行//goto 语句cout << "1、xxxx" << endl;cout << "2、xxxx" << endl;goto FLAG;cout << "3、xxxx" << endl;cout << "4、xxxx" << endl;FLAG:cout << "5、xxxx" << endl;system("pause");return 0;
}

五.数组

5.1概述

所谓数组，就是一个集合，里面存放了相同类型的数据元素

特点1：数组中的每个数组元素都是相同的数据类型

特点2：数组是由连续的内存位置组成的

5.2一维数组

一维数组的定义方式

一维数组定义的三种方式

1. 数据类型 数组名[数组长度]

1. 数据类型 数组名[数组长度] ={值1.值2.......}

1. 数据类型 数组名[ ]={值1.值2..........}

#include<iostream>
using namespace std;
int main()
{int arr[5];arr[0] = 10;arr[1] = 20;arr[2] = 30;arr[3] = 40;arr[4] = 50;//访问数据元素cout << arr[0] << endl;//如果在初始化数据时候，没有全部填写完，会用0来填补剩余的数据int arr1[5] = { 10,20,30,40,50 };cout << arr1[0] << endl;for (int i = 0; i <= 4; i++){cout << arr1[i] << endl;}int arr2[] = { 34,53,535,53 };cout << arr2[1] << endl;system("pause");return 0;
}

一维数组数组名

一维数组名称的用途：

1. 可以统计整个数组在内存中所占的长度

1. 可以获取数组在内存中的首地址

#include<iostream>
using namespace std;
int main()
{//1.可以统计整个数组在内存中所占的长度int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };cout << "整个数组所占内存空间为" << sizeof(arr) << endl;cout << "每个元素所占的内存空间为" << sizeof(arr[0]) << endl;cout << "数组中元素的个数为" << sizeof(arr) / sizeof(arr[0]) << endl;//2.可以获取数组在内存中的首地址cout << "数组的首地址为" << (int)arr << endl;//不加int所展示的是一个十六进制数的首地址，加int强转为10进制的首地址cout << "数组中第一个元素的首地址为" << (int)&arr[0] << endl;cout << "数组中第二个元素的首地址为" << (int)&arr[1] << endl;//第一个元素的首地址（在十进制的情况下）+4=第二个元素的首地址//数组名是常量，不可以进行赋值操作//arr = 100;system("pause");return 0;
}

案例练习1：五只小猪称体重

案例描述：

在一个数组中记录了五只小猪的体重如：int arr[5]={300,350,200,400,250}

找出并打印最重的小猪。

#include<iostream>
using namespace std;
int main()
{//在一个数组中记录了五只小猪的体重如：int arr[5] = { 300,350,200,400,250 }//找出并打印最重的小猪。int arr[5] = { 300,350,200,400,250 };int max = arr[0];for (int i = 1; i <= 4; i++){if (arr[i] > max){max = arr[i];}}cout << "最重小猪的体重为：" << max << endl;system("pause");return 0;
}

案例练习2：数组元素逆置

案例描述：请声明一个5个元素的数组，并且将元素逆置。

（如预原数组元素为：1,3,2,5,4；逆置后输出的结果为4,5,2,3,1）；

#include<iostream>
using namespace std;
int main()
{//实现元素的逆置//1、创建数组int arr[5] = { 1,3,2,5,4 };cout << "数组逆置前： " << endl;for (int i = 0; i <= 4; i++){cout << arr[i];}cout << endl;//2、实现逆置//2.1记录起始下标的位置//2.2记录结束下标的位置//2.3起始下标与原始下标的元素互换//2.4起始位置++，结束位置——//2.5循环2.1操作，直到起始位置>=结束位置int start = 0;int end = sizeof(arr) / sizeof(arr[0]) - 1;//结束下标//实现元素互换while (start < end){int temp = arr[start];arr[start] = arr[end];arr[end] = temp;//下标更新start++;end--;}//3、打印逆置后的数组cout << "数组逆置后： " << endl;for (int i = 0; i <= 4; i++){cout << arr[i];}cout << endl;system("pause");return 0;
}

冒泡排序

作用：最常用的排序算法，对数组内元素进行排序

1.比较相邻的元素。如果第一个比第二个大，就交换他们两个。

2.对每一对相邻元素做同样的工作，执行完毕后，找到第一个最大值。

3.重复以上的步骤，每次比较次数-1，直到不需要比较。

示例：将{4,2,8,0,5,7,1,3,9}进行升序排序。

#include<iostream>
using namespace std;
int main()
{//利用冒泡排序实现升序序列int arr[9] = {4,2,8,0,5,7,1,3,9};cout << "排序前： " << endl;for (int i = 0; i < 9; i++){cout << arr[i] << "  ";}cout << endl;//开始冒泡排序//排序的总轮数=元素个数-1for (int i = 0; i < 9 - 1; i++){//内层循环对比 次数=元素个数-当前轮数-1for (int j = 0; j < 9 - i - 1; j++){//如果第一个数字比第二数字大，实现交换这两个数字if (arr[j] > arr[j + 1]){int temp = arr[j];arr[j] = arr[j+1];arr[j + 1] = temp;}}}//排序后的结果cout << "排序后  " << endl;for (int i = 0; i < 9; i++){cout << arr[i] << "  ";}cout << endl;system("pause");return 0;
}

5.3二维数组

二维数组就是在一维数组上，多加一个维度

二维数组的定义方式

二维数组定义的四种方式：

1. 数据类型 数组名[行数] [列数];

1. 数据类型数组名[行数] [列数]={ {数据1，数据2} },{ {数据3，数据4} };

1. 数据类型数组名[行数] [列数]={数据1，数据2，数据3，数据4};

1. 数据类型数组名[] [列数]={数据1，数据2，数据3，数据4};

#include<iostream>
using namespace std;
int main()
{//1.数据类型  数组名[行数][列数];int arr[2][3];arr[0][0] = 1;arr[0][1] = 2;arr[0][2] = 3;arr[1][0] = 4;arr[1][1] = 5;arr[1][2] = 6;cout << arr[0][0] << endl;cout << arr[0][1] << endl;cout << arr[0][2] << endl;cout << arr[1][0] << endl;cout << arr[1][1] << endl;cout << arr[1][2] << endl;//外层循环打印行数，内层循环打印列数for (int i = 0; i < 2; i++){for (int j = 0; j < 3; j++){cout << arr[i][j] << endl;}}//2.数据类型 数组名[行数][列数] = { {数据1，数据2} }, { {数据3，数据4}};int arr2[2][3] = { {1,2,3},{4,5,6} };for (int i = 0; i < 2; i++){for (int j = 0; j < 3; j++){cout << arr2[i][j] << "  ";}cout << endl;}//3.数据类型 数组名[行数][列数] = { 数据1，数据2，数据3，数据4 };int arr3[2][3] = { 1,2,3,4,5,6 };for (int i = 0; i < 2; i++){for (int j = 0; j < 3; j++){cout << arr3[i][j] << "  ";}cout << endl;}//4.数据类型 数组名[][列数] = { 数据1，数据2，数据3，数据4 };//可以不写行数，但是不能不写列数int arr4[][3] = { 1,2,3,4,5,6 };for (int i = 0; i < 2; i++){for (int j = 0; j < 3; j++){cout << arr4[i][j] << "  ";}cout << endl;}system("pause");return 0;
}

二维数组数组名

查看二维数组所占内存空间

获取二维数组的首地址

#include<iostream>
using namespace std;
int main()
{//二维数组名称用途//1、可以查看占用内存空间的大小int arr[2][3] = { 1,2,3,4,5,6 };cout << "二维数组arr所占内存空间的大小为： " << sizeof(arr) << endl;cout << "二维数组第一行所占用的内存空间为: " << sizeof(arr[0]) << endl;cout << "二维数组第一个元素所占用的内存空间为： " << sizeof(arr[0][0]) << endl;cout << "二维数组的行数为" << sizeof(arr) / sizeof(arr[0]) << endl;cout << "二维数组的列数为" << sizeof(arr[0]) / sizeof(arr[0][0]) << endl;//2、可以查看二维数组的首地址cout << "二维数组的首地址为 " << arr << endl;//转为十进制加intcout << "二维数组的首地址为 " << (int)arr << endl;cout << "二维数组第一行的首地址为 " << (int)arr[0] << endl;cout << "二维数组第二行的首地址为 " << (int)arr[1] << endl;cout << "二维数组第一个元素的的首地址为 " << (int)&arr[0][0] << endl;cout << "二维数组第二个元素的的首地址为 " << (int)&arr[0][1] << endl;system("pause");return 0;
}

维数组应用的案例

考试成绩统计：

案例描述：有三名同学（张三，李四，王五），在一次考试中的成绩如下表，请分别输出三名同学的总成绩

#include<iostream>
using namespace std;
#include<string>
int main()
{//1、创建二维数组int score[3][3] = { {100,100,100},{90,50,100},{60,70,80} };string names [3] = { "张三","李四","王五" };//2、统计每个人的总和分数for (int i = 0; i < 3; i++){int sum = 0;//统计分数总和的变量for (int j = 0; j < 3; j++){sum += score[i][j];//cout << score[i][j] << "  ";}//cout << endl;cout << names[i]<<"的总分为  " << sum << endl;}system("pause");return 0;
}

六.函数

6.1概述

作用：将一段经常使用的代码封装起来，减少重复代码

一个较大的程序，一般分为若干个程序块，每个模块实现特定的功能

6.2函数的定义

函数的定义有5个步骤：

1. 返回值类型

1. 函数名

1. 参数列表

1. 函数体语句

1. return表达式

语法：

返回值类型 函数名 {参数列表}

{

函数体语句

return表达式

}

返回值类型：一个函数可以返回一个值，在函数定义中

函数名：给函数起个名称

参数列表：使用该函数时，传入数据

函数体语句：花括号内的代码，函数需要执行的语句

return表达式：和返回值类型挂钩，函数执行完后，返回相应的数据

#include<iostream>
using namespace std;//函数的定义
//语法：
//返回值类型  函数名（参数列表）{函数体语句  return表达式}
//加法函数，实现两个整型相加，并且将相加的结果进行返回
int add(int num1, int num2)
{int sum = num1 + num2;return sum;
}
int main()
{system("pause");return 0;
}

6.3函数的调用

功能：使用定义好的函数

语法：函数名（参数）

#include<iostream>
using namespace std;
//定义一个加法的函数
//函数定义的时候，num1和num2并没有真实数据，他只是形式上的参数，简称形参
int add(int num1, int num2)
{int sum = num1 + num2;return sum;
}
int main()
{//main函数中调用add函数int a = 10;int b = 20;//函数调用的语法：函数名称（参数）//a和b称为实际的参数//当调用这个函数的时候实参的值会传递给形参int c = add(a, b);cout << "c= " << c << endl;a = 100;b = 200;c = add(a, b);cout << "c= " << c << endl;system("pause");return 0;
}

总结：；函数定义里小括号内称为形参，函数调用时传入的参数称为实参

6.4值传递

所谓值传递，就是函数调用时实参将数值传入给形参。

值传递时，如果形参发生改变，并不会影响实参。

#include<iostream>
using namespace std;
//值传递
//定义函数，实现两个数字进行交换
//如果一个函数不需要返回值，声明的时候可以写void
void swap(int num1, int num2)
{cout << "交换前： " << endl;cout << "num1 = " << num1 << endl;cout << "num2 = " << num2 << endl;int temp = num1;num1 = num2;num2 = temp;cout << "交换后： " << endl;cout << "num1 = " << num1 << endl;cout << "num2 = " << num2 << endl;//return;返回值不需要的时候，可以不写return
}
int main()
{int a = 10;int b = 20;cout << "a = " << a << endl;cout << "b = " << b << endl;swap(a, b);cout << "a = " << a << endl;cout << "b = " << b << endl;//我们做值传递的时候，函数的形参发生改变，并不会影响实参。system("pause");return 0;
}

6.5函数的常见样式

常见的函数样式有4种

1. 无参无返

1. 有参无返

1. 无参有返

1. 有参有返

#include<iostream>
using namespace std;
//常见的函数样式有4种
//1.无参无返
void test01()
{cout << "this is test 01" << endl;
}
//2.有参无返
void test02(int a)
{cout << "this is test 02" << endl;
}
//3.无参有返
int test03()
{cout << "this is test 03" << endl;return 1000;
}
//4.有参有返
int test04(int a)
{cout << "this is test04 a = " << a << endl;return a;
}
int main()
{//1.无参无返调用test01();//2.有参无返调用test02(100);//3.无参有返int num1 = test03();cout << "num1 = " << num1 << endl;//4.有参有返的函数调用int num2 = test04(10000);cout << "num2 = " << num2 << endl;system("pause");return 0;
}

6.6函数的声明

作用：告诉编译器函数名称及如何调用函数，函数的实际主体可以单独定义

函数的声明可以多次，但是函数的定义只有一次。

#include<iostream>
using namespace std;
//函数的声明
//比较函数，实现两个整形数字进行比较，返回较大的值
//提前告诉编译器函数的存在，可以利用函数的声明
//函数的声明
//声明可以写一次，但是定义只能写一次
int max(int a, int b);
int main()
{int a = 10;int b = 20;cout << max(a, b) << endl;system("pause");return 0;
}
int max(int a, int b)
{return a > b ? a : b;
}

6.7函数的分文件编写

作用：让代码结构更加清晰

函数分文件编写一共有4个步骤

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

1. 创建后缀名为.cpp的源文件

1. 在头文件中写函数的声明

1. 在源文件中写函数的定义

这个需要自己看视频。来加强自己的认知。

七.指针

7.1指针的基本概念

指针的作用：可以通过指针直接访问内存

内存编号是从0开始记录的，一般用十六进制数字表示

可以利用指针变量保存地址

7.2指针变量的定义与使用

指针变量定义语法：数据类型*变量名;

#include<iostream>
using namespace std;
int main()
{int a = 10;//1.定义指针的语法：数据类型*指针变量名；int* p;//让指针记录变量a的地址p = &a;cout << "a的地址为：" << &a << endl;cout << "指针p的地址为： " << p << endl;//2.使用指针//可以通过解引用的方式来找到指针指向的内存//指针前加 * 代表解引用，找到指针指向的内存中的数据*p = 1000;cout << "a = " << a << endl;cout << " *p " << *p << endl;system("pause");return 0;
}

7.3指针所占的内存空间

提问：指针也是种数据类型，那么这种数据类型占多少内存空间？

#include<iostream>
using namespace std;
int main()
{int a = 10;//int* p;//p = &a;int* p = &a;//在32位操作系统下，指针占用4个字节空间大小，不管是什么数据类型//在64位操作系统下，指针是占8个字节空间大小，不管在什么数据类型cout << "sizeof(int *) = " << sizeof(int*) << endl;//p和int*可以互换cout << "sizeof(float *) = " << sizeof(float*) << endl;cout << "sizeof(double *) = " << sizeof(double*) << endl;cout << "sizeof(char *) = " << sizeof(char*) << endl;    system("pause");return 0;
}

7.4空指针和野指针

空指针：指针变量指向内存空间中编号为0的空间

用途：初始化指针变量

注意：空指针指向的内存是不可以访问的

#include<iostream>
using namespace std;
int main()
{//空指针//1.空指针用于给指针变量进行初始化int* p = NULL;//2.空指针是不可以进行访问的//0~255之间的内存编号是系统占用的，因此不可访问//*p = 100;system("pause");return 0;
}

野指针：指针变量指向非法的内存空间

#include<iostream>
using namespace std;
int main()
{//野指针//在程序中，尽量避免出现野指针int* p = (int *)0x1100;cout << *p << endl;system("pause");return 0;
}

总结：空指针和野指针都不是我们申请的空间，因此不要访问。

7.5const修饰指针

const修饰指针有三种情况：

1. const修饰指针 ......常量指针

1. Const修饰常量 ......指针常量

1. Const既修饰指针，又修饰常量

#include<iostream>
using namespace std;
int main()
{//1、const修饰指针 常量指针int a = 10;int b = 10;const int* p = &a;//指针指向的值不可以更改，指针的指向可以改 //*p = 20;错误p = &b;//正确//2、Const修饰常量 int* const p2 = &a;//指针的指向不可以改，指针指向的值可以改*p2 = 20;//正确//p2 = &b;错误//3、Const既修饰指针，又修饰常量const int* const p3 = &a;//指针的指向和指针指向的值都不可以改//*p3 = 20;//错误//p3 = &b;错误system("pause");return 0;
}

7.6指针和数组

作用：利用指针访问数组中元素

#include<iostream>
using namespace std;
int main()
{//指针和数组//利用指针访问数组中的元素int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };cout << "第一个元素为： " << arr[0] << endl;int* p = arr;//arr就是数组的首地址cout << "利用指针来访问第一个元素： " << *p << endl;p++;//让指针向后偏移4个字节cout << "利用指针来访问第二个元素： " << *p << endl; //这里已经经过了p++，所以只要让*(p+1)即可访问第三个元素cout << "利用指针来访问第三个元素： " << *（p+1） << endl;cout << "利用指针遍历数组" << endl;int* p2 = arr;for (int i = 0; i < 10; i++){//cout << arr[i] << endl;cout << *p2 << endl;p2++;}system("pause");return 0;
}

7.7指针和函数

作用：利用指针作函数参数，可以修改实参的值

#include<iostream>
using namespace std;
//实现两个数字进行交换
void swap01(int a, int b)
{int temp = a;a = b;b = temp;cout << "swap01 a= " << a << endl;cout << "swap02 b= " << b << endl;
}
void swap02(int* p1, int* p2)
{int temp = *p1;*p1 = *p2;*p2 = temp;
}
int main()
{//指针和函数//1、值传递   值传递不会改变实参int a = 10;int b = 20;//swap01(a, b);swap02(&a, &b);cout << "a= " << a << endl;cout << "b= " << b << endl;//2、地址传递  地址传递会改变实参//如果是地址传递，可以修饰实参system("pause");return 0;
}

7.8指针，数组，函数

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

例如数组：int arr[10]={4,3,6,9,1,2,10,8,7,5};

#include<iostream>
using namespace std;
//冒泡排序函数 参数1 数组的首地址  参数2 数组长度
void bubblesort(int *arr,int len)
{for (int i = 0; i < len - 1; i++){for (int j = 0; j < len - i - 1;j++){//如果j>j+1的值  交换数字if (arr[j] > arr[j + 1]){int temp = arr[j];arr[j] = arr[j + 1];arr[j + 1] = temp;}}}
}
//打印数组
void printArray(int* arr, int len)
{for (int i = 0; i < len; i++){cout << arr[i] << endl;}
}
int main()
{//1、先创建数组int arr[10] = { 4,3,6,9,1,2,10,8,7,5 };//数组长度int len = sizeof(arr) / sizeof(arr[0]);//2、创建函数，实现冒泡排序bubblesort(arr, len);//3、打印排序后的数组printArray(arr, len);system("pause");return 0;
}

八.结构体

8.1结构体的基本概念

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

8.2结构体定义和使用

语法：struct 结构体名 {结构体成员列表};

通过结构体创建变量的方式有三种：

struct 结构体 变量名

struct 结构体名 变量名={成员1值，成员2值....}

定义结构时顺便创建变量

#include<iostream>
using namespace std;
#include<string>
//1、创建学生的数据类型：学生包括（姓名，年龄，分数）
//自定义数据类型，一些类型集合组成的一个类型
//语法 struct 类型名称 {成员列表}
struct student
{//成员列表//姓名string name;//年龄int age;//分数int score;
}s3;//顺便创建一个结构体变量
//2、通过学生类型创建具体学生
int main()
{//struct的关键字可以省略，上面那个struct不可以省略//2.1 struct student s1struct student s1;//通过.来访问结构体变量中的属性s1.name = "张三";s1.age = 18;s1.score = 100;cout << "姓名 " << s1.name << "年龄 " << s1.age << "分数 " << s1.score << endl;//2.2 struct student s2={......}struct student s2 = { "李四",19,80 };cout << "姓名 " << s2.name << "年龄 " << s2.age << "分数 " << s2.score << endl;//2.3 在定义结构体时，顺便创建结构体变量s3.name = "王五";s3.age = 20;s3.score = 60;cout << "姓名 " << s3.name << "年龄 " << s3.age << "分数 " << s3.score << endl;system("pause");return 0;
}

8.3结构体数组

作用：将自定义额结构放入到数组中方便维护

语法：struct 结构体名 数组名{元素个数}={ {},{}......}

#include<iostream>
using namespace std;
#include<string>
//结构体数组
//1、定义结构体
struct Student
{//姓名string name;//年龄int age;//分数int score;
};
int main()
{//2、创建结构体数组struct Student stuArray[3] ={{"张三",18,100},{"李四",28,99},{"王五",38,66}};//3、给结构体中的元素赋值stuArray[2].name = "赵六";stuArray[2].age = 80;stuArray[2].score = 60;//4、遍历结构体数组for (int i = 0; i < 3; i++){cout << "姓名 " << stuArray[i].name << "年龄 " << stuArray[i].age << "分数 " << stuArray[i].score << endl;}system("pause");return 0;
}

8.4结构体指针

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

利用操作符->可以通过结构体指针访问结构体属性

#include<iostream>
using namespace std;
#include<string>
//结构体指针
//定义学生的结构体
struct student
{string name;//姓名int age;    //年龄int scoer;  //分数
};
int main()
{//1、创建学生的结构体变量struct student s = { "张三",18,100 };//2、通过指针指向结构体变量struct student* p = &s;     //struct可以省略//3、通过指针访问结构体变量中的数据cout << "姓名 " << p->name << "年龄 " << p->age << "分数 " << endl;system("pause");return 0;
}

8.5结构体嵌套结构体

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

例如：每个老师辅导一个学员，一个老师的结构体中，记录一个学生的结构体

#include<iostream>
using namespace std;
#include<string>
//定义学生的结构体
struct student
{string name; //姓名int age;     //年龄int score;   //分数
};
//定义一个老师的结构体
struct teacher
{int id;        //教师编号string name;   //教师姓名int age;       //教师年龄struct student stu;   //辅导的学生
};
int main()
{//结构体嵌套结构//创建老师teacher t;t.id = 10000;t.name = "老王";t.age = 50;t.stu.name = "小王";t.stu.age = 20;t.stu.score = 60;cout << "老师的姓名 " << t.name << "老师的编号 " << t.id << "老师的年龄 " << t.age<< "老师辅导的学生姓名： " << t.stu.name << "学生的年龄： " << t.stu.age<< "学生的成绩： " << t.stu.score << endl;system("pause");return 0;
}

8.6结构体做参数函数

作用：将结构体作为参数向函数中传递

传递方式有两种：

值传递

地址传递

#include<iostream>
using namespace std;
#include<string>
struct student
{string name; //姓名int age;     //年龄int score;   //分数
};
//打印学生信息函数
//1、值传递
void printStudent1(struct student s)
{s.age = 100; //更改之后main函数中值不变cout << "子函数中  姓名：" << s.name << "年龄：" << s.age << "分数：" << s.score << endl;
}
//2、地址传递
void printStudent2(struct student* p)
{p->age = 200;//更改之后main函数中值变化cout << "子函数2中 姓名：" << p->name << "年龄：" << p->age << "分数：" << p->score << endl;
}
int main()
{//结构体做函数参数//将学生传入到一个函数中，打印学生身上的所有信息//创建结构体变量struct student s;s.name = "张三";s.age = 20;s.score = 80;//cout << "main函数中打印 姓名：" << s.name << "年龄：" << s.age << "分数：" << s.score << endl;printStudent1(s);printStudent2(&s);cout << "在main函数中  姓名：" << s.name << "年龄：" << s.age << "分数：" << s.score << endl;system("pause");return 0;
}

8.7结构体中const的使用场景

作用：用const来防止误操作

#include<iostream>
using namespace std;
#include<string>
//const的使用场景
struct student
{//姓名string name;//年龄int age;//分数int scoer;
};
//将函数中的形参改为指针，可以减少内存空间，而且不会复制新的副本出来
void printStudent(const student *s)
{//s->age = 50; 加入const后，一旦有修改的操作就会报错，可以防止我们的误操作cout << "姓名：" << s->name << "年龄：" << s->age << "分数：" << s->scoer << endl;
}
int main()
{//创建结构体变量struct student s = { "张三",16,70 };//通过函数来打印结构体变量信息printStudent(&s);cout << "在main函数中张三的年龄为：" << s.age << endl;system("pause");return 0;
}

8.8结构体案例

案例1

案例描述：

学校正在做毕设项目，每名老师带领5个学生，总共有3名老师，需求如下

设计老师和学生的结构体，其中在老师的结构体中，有老师姓名和一个存放5名学生的数组作为成员

学生的成员有姓名，考试分数，创建数组存放3名老师，通过函数给每位老师及所带的学生赋值，最终打印出老师数据以及老师所带学生的数据

#include<iostream>
using namespace std;
#include<string>
#include<Ctime>
//学生的结构体
struct Student
{//姓名string sName;//分数int score;
};
//老师的结构体的定义
struct Teacher
{//姓名string tName;//学生数组struct Student sArray[5];
};
//给老师和学生赋值的函数值
void allocateSpace(struct Teacher tArray[],int len)
{string nameSeed = "ABCDE";//给老师开始赋值for (int i = 0; i < len; i++){tArray[i].tName = "Teacher_";tArray[i].tName += nameSeed[i];//通过循环给每名老师所带的学生赋值for (int j = 0; j < 5; j++){tArray[i].sArray[j].sName = "Student_";tArray[i].sArray[j].sName += nameSeed[j];int random = rand() % 61+40;   //40~100tArray[i].sArray[j].score = random;}}
}
//打印所有信息
void printInfo(struct Teacher tArray[],int len)
{for (int i = 0; i < len; i++){cout << "老师的姓名  " << tArray[i].tName << endl;for (int j = 0; j < 5; j++){cout << "\t学生的姓名为：" << tArray[i].sArray[j].sName << "成绩为："<< tArray[i].sArray[j].score << endl;}}
}
int main()
{//随机数种子srand((unsigned int)time(NULL));//1.创建三名老师的数组struct Teacher tArray[3];//2.通过函数给三名老师的信息赋值，并给老师带的学生信息赋值int len = sizeof(tArray) / sizeof(tArray[0]);allocateSpace(tArray, len);//3.打印所有老师及所带学生信息printInfo(tArray, len);system("pause");return 0;
}

案例2

案例描述：

设计一个英雄的结构体，包括成员姓名，年龄，性别，创建结构体数组，数组中存放5名英雄

通过冒泡排序的算法，将数组中的英雄按照年龄进行升序排序，最终打印排序后的结果

五名英雄信息如下：

{"刘备",23,"男"},

{"关羽",22,"男"},

{"张飞",20,"男"},

{"赵云",21,"男"},

{"貂蝉",19,"女"}.

#include<iostream>
using namespace std;
#include<string>
//1.创建英雄的结构体
struct Hero
{//姓名string name;//年龄int age;//性别string sex;
};
//冒泡排序 实现年龄升序
//void bubbleSort(struct Hero heroArray[], int len)
//{
//    for (int i = 0; i < len - 1; i++)
//    {
//        for (int j = 0; j < len - i - 1; j++)
//        {
//            if (heroArray[j].age > heroArray[j + 1].age)
//            {
//                int temp = heroArray[j].age;
//                heroArray[j].age = heroArray[j + 1].age;
//                heroArray[j + 1].age = temp;
//            }
//        }
//    }
//}
void bubbleSort(struct Hero heroArray[], int len)
{for (int i = 0; i < len - 1; i++){for (int j = 0; j < len - i - 1; j++){if (heroArray[j].age > heroArray[j + 1].age){struct Hero temp = heroArray[j];heroArray[j] = heroArray[j + 1];heroArray[j + 1] = temp;}}}
}
//打印排序后的输出信息
void printSort(struct Hero heroArray[], int len)
{for (int i = 0; i < len; i++){cout << "姓名 " << heroArray[i].name << "年龄 " << heroArray[i].age<< "性别 " << heroArray[i].sex << endl;}
}
int main()
{//2.创建一个数组存放五名英雄struct Hero heroArray[5] ={{"刘备",23,"男"},{"关羽",22,"男"},{"张飞",20,"男"},{"赵云",21,"男"},{"貂蝉",19,"女"},};int len = sizeof(heroArray) / sizeof(heroArray[0]);/*for(int i = 0; i < len; i++){cout << "姓名 " << heroArray[i].name << "年龄 " << heroArray[i].age<< "性别 " << heroArray[i].sex << endl;}*///3.对数组进行排序，按照年龄进行升序排序bubbleSort(heroArray,len);//4.排序后的结果打印输出printSort(heroArray, len);system("pause");return 0;
}