【黑马程序员匠心之作|C++教程从0到1入门编程,学习编程不再难】 https://www.bilibili.com/video/BV1et411b73Z?p=72&share_source=copy_web&vd_source=f69f657cb8ef03a4f5663f02aaa0869c
课程学习笔记
目录
1.初识C++
1.1注释
单行注释 | //描述 |
多行注释 | /*描述*/ |
1.2变量
作用:给指定的内存空间起名,方便操作
语法:数据类型 变量名 = 初始值;
1.3常量
作用;用于记录程序中不可更改的数据
C++定义常量两种方式:
- #define 宏常量:#define 常量名 常量值
通常在文件上方定义,表示一个常量
- 2.const修饰的变量:const 数据类型 常量名 = 常量值
通常在变量定义前加关键字const,修饰该变量为常量,不可修改
1.4关键字
作用:关键字是C++中预先保留的单词(标识符)
在定义变量的时候不要使用关键字
1.5标识符的命名规则
作用:C++规定给标识符(变量、常量)命名时,有一套自己的规则
标识符不能是关键字
标识符只能由字母、数字、下划线组成
第一个字符必须为字母或下划线
标识符中字母区分大小写
2.数据类型
创建任意变量或常量需要规定数据类型,否则无法对变量分配内存
2.1整型
作用:整型变量表示整数类型的数据
以下几种可以表示整数,区别在于所占内存不同
Short(短整型) | 2字节 | -2^15—2^15-1 |
int(整型) | 4字节 | -2^31—2^31-1 |
Long(长整型) | windows 4字节 | ~ |
Long long(长长整型) | 8字节 | -2^63—2^63-1 |
2.2sizeof关键字
作用:统计数据类型所占内存大小
语法:sizeof(数据类型/变量)
例:
#include<iostream>
using namespace std;
int main()
{
short num1= 10;
cout << sizeof short:<<sizeof(short/num1)<<endl;
system("pause");
return 0;
}
2.3实型(浮点型)
作用:用来表示小数
两种:单精度float,双精度double。
两者区别在于表示的有效数字范围不同
float | 4字节 | 7位有效数字 |
double | 8字节 | 15-16位有效数字 |
默认情况下,输出一个小数,会显示六位有效数字
例:float f1 = 3.14f
若不写f,则f1 = 3.14是双精度再float为单精度
写了f,f1直接就为单精度
2.4字符型
作用:字符型变量用于显示单个字符
语法:char ch = ‘a’;
注:显示字符型变量时,用单引号不要用双引号
单引号内只能有一个字符,不可以是字符串
·c和c++中字符型变量只占用一个字节
·字符型变量并不是把字符本身放到内存中存储,而是将对应的 ASCII编码放到存储单元
·字符型变量对应的ASCII码
a——97 A——65
(int)ch——将字符型变量a的ASCII码强转为整数型让我们看到
2.5转义字符
作用:用于表示一些不能显示出来的ASCII字符
现阶段常用的转义字符有:\n \\ \t
\\ 反斜杠 \n 换行 \t 水平制表符
cout<<”hello world\n;——hello world
cout<<”\\”<<endl;——\
cout<<”aaa\thello world”<<endl;——aaa hello world
2.6字符串型
作用:用于表示一串字符
两种风格:
1.c风格字符串:char 变量名[] = “字符串值”
例:
char str1[] = “hello world”
注:c风格的字符串要用双引号括起来
2.c++风格字符串:string 变量名 = “字符串值”
例:
string str1 = “hello world”
注:使用该风格需要引入头文件#include <string>
2.7布尔类型bool
作用:布尔数据类型代表真或假的值
bool类型只有两个值:true --真(本质是1)false--假(本质是0)
bool类型占一个字节的大小
例:
#include<iostream>
using namespace std;
int main()
{
bool flag = true;
cout << flag << endl;
system("pause");
return 0;
}
2.8数据的输入
作用:用于从键盘获取数据
关键字:cin
语法:cin >> 变量
#include<iostream>
using namespace std;
#include<string>
int main()
{
//整型
int a = 0;
cout << "请输入数字a的值" << endl;
cin >> a;//输入a
cout << "a的值是:"<<a << endl;
//浮点型
float f = 3.14f;
cout << "请输入数字f的值" << endl;
cin >> f;//输入f
cout << "f的值是:" << f << endl;
//字符型
char ch = 'a';
cout << "请输入ch的值" << endl;
cin >> ch;//输入字符
cout << "ch的值是:" << ch << endl;
//c++型字符串
string o = "hello";
cout << "请输入o的值" << endl;
cin >> o;//输入字符串
cout << "o的值是:" << o << endl;
//bool型
bool k = true;
cout << "请输入k的值" << endl;
cin >> k;//输入布尔型
cout << "o的值是:" << k << endl;
system("pause");
return 0;
}
3.运算符
作用:用于执行代码的运算
运算符类型 | 作用 |
算数运算符 | 处理四则运算 |
赋值运算符 | 将表达式的值赋给变量 |
比较运算符 | 用于表达式的比较并返回一个布尔值 |
逻辑运算符 | 根据表达式的值返回布尔值 |
3.1算数运算符
作用:用于处理四则运算
算数运算符包括以下符号
运算符 | 术语 | 示例 | 结果 |
+ | 正号 | +3 | 3 |
- | 负号 | -3 | -3 |
+ | 加号 | 10+5 | 15 |
- | 减号 | 10-5 | 5 |
* | 乘 | 10*5 | 50 |
/ | 除 | 10/5 | 2 |
% | 取模(取余) | 10%3 | 1 |
++ | 前置递增 | a=2;b=++a; | a=3;b=3; |
++ | 后置递增 | a=2;b=a++; | a=3;b=2; |
-- | 前置递减 | a=2;b=--a; | a=1;b=1; |
-- | 后置递减 | a=2;b=a--; | a=1;b=2; |
前置后置的区别:
前置递增:先让变量+1,再运算表达式
后置递增:先运算表达式,再让变量+1
#include<iostream>
using namespace std;
#include<string>
int main()
{
int num1 = 3;
int num2 = 2;
cout << num1 + num2 << endl;//加
cout << num1 - num2 << endl;//减
cout << num1 * num2 << endl;//乘
cout << num1 / num2 << endl;//得到结果为1,整数相除结果仍为整数,小数位被舍弃,除数也不可为0
//两个小数是不可以进行取模运算的
cout << num1 % num2 << endl;//取余,分母也不可为0
//前置递增
++num1;//让变量进行+1操作
cout << "num1=" << num1 << endl;
//后置递增
num2++;//让变量+1
cout << "num2=" << num2 << endl;
//前置后置区别
int a = 10;
int a1 = ++a * 10;
cout << "a=" << a << "\na1=" << a1 << endl;//a先+1再运算
int b = 10;
int b1 = b++ * 10;
cout << "b=" << b << "\nb1=" << b1 << endl;//先运算,b再+1
//前置递减
int c = 10;
--c;//-1
cout << "c=" << c << endl;
//后置递减
int d = 10;
d--;//-1
cout << "d=" << d << endl;
//前置递减与后置递减区别
int e = 10;
int e1 = --e * 10;
cout << "e=" << e << "\ne1=" << e1 << endl;//先-1再做运算
int f = 10;
int f1 = f-- * 10;
cout << "f=" << f << "\nf1=" << f1 << endl;//先做运算再-1
system("pause");
return 0;
}
3.2赋值运算符
作用:用于将表达式的值赋给变量
赋值运算符包括以下符号
运算符 | 术语 | 示例 | 结果 |
= | 赋值 | a=2;b=3 | a=2;b=3 |
+= | 加等于 | a=0;a+=2; | a=2; |
-= | 减等于 | a=5;a-=3; | a=2; |
*= | 乘等于 | a=2;a*=2; | a=4; |
/= | 除等于 | a=4;a/=2; | a=2; |
%= | 模等于 | a=3;a%=2; | a=1; |
a+=2即a=a+2;其他同理
3.3比较运算符
作用:用于表达式的比较,并返回一个真值或假值
比较运算符有以下符号:
运算符 | 术语 | 示例 | 结果 |
== | 相等于 | 4==3 | 0 |
!= | 不等于 | 4!=3 | 1 |
< | 小于 | 4<3 | 0 |
> | 大于 | 4>3 | 1 |
<= | 小于等于 | 4<=3 | 0 |
>= | 大于等于 | 4>=3 | 1 |
#include<iostream>
using namespace std;
#include<string>
int main()
{
int a = 4;
int b = 3;
cout << (a == b) << endl;//均需要括号括起来
cout << (a != b) << endl;
cout << (a < b) << endl;
cout << (a > b) << endl;
cout << (a <= b) << endl;
cout << (a >= b) << endl;
system("pause");
return 0;
}
3.4逻辑运算符
作用:用于根据表达式的值返回真值或假值
逻辑运算符有以下符号:
运算符 | 术语 | 示例 | 结果 |
! | 非 | !a | 如果a为假,则!a为真;反之亦然 |
&& | 与 | a&&b | 如果a和b都为真,则结果为真,否则为假 |
|| | 或 | a||b | 如果a和b有一个为真,则结果为真,二者均为假,结果才假 |
#include<iostream>
using namespace std;
#include<string>
int main()
{
//逻辑非
int a = 10;
cout << !a << endl;//0
cout << !!a << endl;//1
//逻辑与
int b = 5;
int c = 0;
cout << (a && b) << endl;//1
cout << (a && c) << endl;//0
//逻辑或
int d = 0;
cout << (a || b) << endl;//1
cout << (a || c) << endl;//1
cout << (c || d) << endl;//0
system("pause");
return 0;
}
4.程序流程结构
c/c++支持最基本的三种程序运行结构:顺序结构、选择结构、循环结构
- 顺序结构:程序按顺序执行,不发生跳转
- 选择结构:依据条件是否满足,有选择的执行相应功能
- 循环结构:依据条件是否满足,循环多次执行某段代码
4.1选择结构
4.1.1.if语句
作用:执行满足条件的语句
if语句的三种形式
- 单行格式if语句
- 多行格式if语句
- 多条件的if语句
注意:if条件后面不加分号,若加了会与后面语句分离,不论条件是否成立都会执行后面内容
#include<iostream>
using namespace std;
#include<string>
int main()
{
//单行if语句
int num = 0;
cout << "请输入数字:" << endl;//提示
cin >> num;//输入
//注意if条件后面不加分号,若加了会与后面语句分离,不论条件是否成立都会执行后面内容
if (num >= 80)//判断
{
cout << "您的成绩是:" << num << ",属于优秀。" << endl;
}
//多行格式if语句,比单行多了else
int num1 = 0;
cout << "请输入数字:" << endl;//提示
cin >> num1;//输入
if (num1 >= 80)//判断
{
cout << "您的成绩是:" << num1 << ",属于优秀。" << endl;
}
else
{
cout << "您的成绩是:" << num1 << ",不属于优秀。" << endl;
}
//多条件的if语句:if...else if...else
int a = 0;
cout << "请输入a的值:" << endl;
cin >> a;
if (a >= 80)
{
cout << "您的成绩是:" << a << ",属于优秀。" << endl;
}
else if (a >= 60 && a < 80)
{
cout << "您的成绩是:" << a << ",属于良好" << endl;
}
else
{
cout << "您的成绩是:" << a << ",成绩不及格" << endl;
}
system("pause");
return 0;
}
嵌套if语句:在if语句中,可以嵌套使用if语句,达到更精确的条件判断
#include<iostream>
using namespace std;
#include<string>
int main()
{
int a = 0;
cout << "请输入a的值:" << endl;
cin >> a;
if (a >= 80)//第一个if语句
{
if (a >= 90)//嵌套一个if语句
{
cout<<"您的成绩是:" << a << ", 属于非常优秀。" << endl;
}
else if (a >= 85 && a < 90)
{
cout << "您的成绩是:" << a << ",属于比较优秀。" << endl;
}
else
{
cout << "您的成绩是:" << a << ",属于一般优秀。" << endl;
}
}
else if (a >= 60 && a < 80)
{
cout << "您的成绩是:" << a << ",属于良好" << endl;
}
else
{
cout << "您的成绩是:" << a << ",成绩不及格" << endl;
}
system("pause");
return 0;
}
例:三只小猪的案例
#include<iostream>
using namespace std;
#include<string>
int main()
{
//三只小猪称体重
//输入三只小猪的体重,判断哪只小猪最重?
int a = 0;
int b = 0;
int c = 0;
cout << "请输入a猪的体重:" << endl;
cin >> a;
cout << "请输入b猪的体重:" << endl;
cin >> b;
cout << "请输入c猪的体重:" << endl;
cin >> c;
if (a > b)
{
cout << "a猪比b猪重" << endl;
if (a > c)
{
cout << "a猪比c猪重" << endl;
if (b > c)
{
cout << "所以,a猪最重,b猪次之,c猪最轻" << endl;
}
else if (b < c)
{
cout << "所以,a猪最重,c猪次之,b猪最轻" << endl;
}
else
{
cout << "所以,a猪最重,b猪和c猪一样重" << endl;
}
}
else if (a<c)
{
cout << "c猪比a猪重,所以c猪最重,a猪次之,b猪最轻" << endl;
}
else
{
cout << "a猪和c猪一样重,b猪最轻" << endl;
}
}
else if (a<b)
{
cout << "b猪比a猪重" << endl;
if (b > c)
{
cout << "b猪比c猪重,所以b猪最重" << endl;
if (a > c)
{
cout << "b猪最重,a猪次之,c猪最轻" << endl;
}
else if (a < c)
{
cout << "b猪最重,c猪次之,a猪最轻" << endl;
}
else
{
cout << "b猪最重,a猪c猪一样重" << endl;
}
}
else if (b < c)
{
cout << "c猪比b猪重,所以c猪最重,b猪次之,a猪最轻" << endl;
}
else
{
cout << "b猪和c猪一样重,a猪最轻" << endl;
}
}
else
{
cout << "a猪和b猪一样重" << endl;
if (a < c)
{
cout << "c猪最重,a猪和b猪一样重" << endl;
}
else if (a > c)
{
cout << "a猪和b猪一样重,c猪最轻" << endl;
}
else
{
cout << "a猪b猪c猪一样重" << endl;
}
}
system("pause");
return 0;
}
4.1 2. 三目运算符
作用:通过三目运算符实现简单的判断
语法:表达式1?表达式2:表达式3
解释:
- 如果表达式1的值为真,执行表达式2,并返回表达式2的结果;
- 如果表达式1的值为假,直行表达式3,并返回表达式3的结果。
C++中,三目运算符返回的是变量,可以继续赋值
#include<iostream>
using namespace std;
#include<string>
int main()
{
int a = 10;
int b = 20;
int c = 30;
c = (a > b ? a : b);//a若大于b,执行a,否则执行b
(a > b ? a : b) = 40;//返回值可以继续赋值,b=40
cout << "a=" << a << "\nb=" << b << "\nc=" << c << endl;
system("pause");
return 0;
}
4.1.3.switch语句
作用:执行多条件分支语句
语法:
switch(表达式)
{
case 结果1:执行语句;break;
case 结果2:执行语句;break;
...
default:执行语句;break;
}
break:退出当前分支,不添加break,会挨个执行每种情况
if 和 switch区别:if 后面的表达式可以表示一个区间,,switch后的表达式不能表示区间只能是一个整型或者字符型,但是switch结构清晰,执行效率高
#include<iostream>
using namespace std;
#include<string>
int main()
{
int a = 0;
cout << "请输入a的分数:" << endl;
cin >> a;
switch (a)
{
case 10:
cout << "您打分为10分,满分" << endl;
break;
case 9:
cout << "您打分为9分,优秀" << endl;
break;
case 8:
cout << "您打分为8分,较好" << endl;
break;
case 7:
cout << "您打分为7分,良好" << endl;
break;
case 6:
cout << "您打分为6分,及格" << endl;
break;
default:
cout << "您打分为" << a << "分,不及格" << endl;
break;
}
system("pause");
return 0;
}
4.2循环结构
4.2.1.while循环语句
作用:满足循环条件,执行循环语句
语法:while(循环条件){循环语句}
解释:只要循环条件的结果为真,就执行循环语句
#include<iostream>
using namespace std;
#include<string>
int main()
{
//while循环打印0-9数字
int num = 0;
while (num < 10)
{
cout << num << endl;
num++;
}
system("pause");
return 0;
}
例:猜数字
系统随机生成一个1-100之间的数字,玩家进行猜测,如果猜错,提示玩家数字过大或过小,如果猜对恭喜玩家胜利,并且退出游戏。
随机数:rand()%100——生成0-99的随机数
可以运用break退出循环
添加随机数种子,利用当前系统时间生成随机数,防止每一次随机数相同
srand((unsigned int)time(NULL));time系统时间的头文件包含
#include<ctime>
#include<iostream>
using namespace std;
//time系统时间的头文件包含
#include<ctime>
int main()
{
//猜数字
int a = 0;
//添加随机数种子,利用当前系统时间生成随机数,防止每一次随机数相同
srand((unsigned int)time(NULL));
int b = rand() % 100 + 1;
while (a != b)
{
cout << "请输入您猜的数字:" << endl;
cin >> a;
if (a > b)
{
cout << "您猜大了" << endl;
}
else if (a < b)
{
cout << "您猜小了" << endl;
}
else
{
cout << "恭喜您猜中了" << endl;
}
}
system("pause");
return 0;
}
4.2.2.do...while循环语句
作用:满足循环条件,执行循环语句
语法:do{循环语句}while(循环条件);
注意:与while的区别在于do...while会先执行一次循环语句,再判断循环条件
#include<iostream>
using namespace std;
#include<string>
int main()
{
//do...while循环打印0-9数字
int num = 0;
do
{
cout << num << endl;
num++;
}
while (num < 10);
system("pause");
return 0;
}
例:水仙花数
水仙花数是指一个三位数,他的每个位上的数字的3次幂之和等于他本身,例如:1^3+5^3+3^3=153,请利用do...while语句,求出所有3位数中的水仙花数
#include<iostream>
using namespace std;
#include<string>
int main()
{
//do...while循环做水仙花数案例
int a = 1;//百位
int b = 0;//十位
int c = 0;//个位
int i = 1;//计数
do
{
if (pow(a,3) + pow(b,3) + pow(c,3) == a * 100 + b * 10 + c)//pow(a,b)a的b次方
{
cout << "第" <<i << "个数是" << a * 100 + b * 10 + c << endl;
i++;
}
if (c < 10)//如果c小于10,c+1,否则即c=10,则b+1,c-10归0
{
c++;
}
else//c=10的情况
{
b++;
if (b == 10)//如果b=10,则a+1,b-10归0,否则即b<10,则c-10归0
{
a++;
b -= 10;
}
c -= 10;
}
}
while (a * 100 + b * 10 + c < 1000);//条件
system("pause");
return 0;
}
#include<iostream>
using namespace std;
#include<string>
int main()
{
//do...while循环做水仙花数案例
int num = 100;
do
{
int a = 0;//百位
int b = 0;//十位
int c = 0;//分位
c = num%10;
b = num / 10 % 10;
a = num / 100;
if (pow(a, 3) + pow(b, 3) + pow(c, 3) == num)//pow(a,b)a的b次方
{
cout << num << endl;
}
num++;
}
while (num<1000);
system("pause");
return 0;
}
4.2.3.for循环语句
作用:满足循环条件,执行循环语句
语法:for(起始表达式;条件表达式;末尾循环体;){ 循环语句 }
起始表达式仅执行一次,条件表达式满足则执行循环语句,之后才执行末未循环体
注意:for内的三个表达式均可以不写,但需要在其他地方写
#include<iostream>
using namespace std;
#include<string>
int main()
{
//for循环打印0-9
for ( int a = 0; a < 10; a++)
{
cout << a << endl;
}
system("pause");
return 0;
}
例:敲桌子
从1开始数到数字100,如果数字个位含有7,或者数字十位含有7,或者该数字是7的倍数,我们打印敲桌子,其余数字直接打印输出。
#include<iostream>
using namespace std;
#include<string>
int main()
{
//敲桌子
for (int a = 1;a<=100 ; a++)
{
if (a % 10 == 7 || a / 10 == 7 || a % 7 == 0)
{
cout << "敲桌子" << endl;
}
else
{
cout << a << endl;
}
}
system("pause");
return 0;
}
4.2.4.嵌套循环
作用:在循环体中再嵌套一层循环,解决一些实际问题
外层执行一次,内层执行一轮
#include<iostream>
using namespace std;
#include<string>
int main()
{
//嵌套循环打印10*10的星图
for (int a = 0; a <= 10; a++)
{
for (int b = 0; b <= 10; b++)
{
cout << "*";
}
cout << endl;//换行
}
system("pause");
return 0;
}
例:乘法口诀表
利用嵌套循环,实现九九乘法表
#include<iostream>
using namespace std;
#include<string>
int main()
{
//嵌套循环
for (int i = 1; i < 10; i++)
{
for (int j = 1; j <=i; j++)
{
cout << j << "×" << i << "=" << i * j<<"\t";
}
cout << endl;
}
system("pause");
return 0;
}
4.3跳转语句
4.3.1.break语句
作用:用于跳出选择结构或者循环结构
break使用的时机;
- 出现在switch条件语句中,作用是中值case并跳出switch
- 出现在循环语句中,作用是跳出当前的循环语句
- 出现在嵌套循环中,跳出最近的内层循环语句
4.3.2.continue语句
作用:在循环语句中,跳过本次循环中余下尚未执行的语句,继续执行下一次循环
break会退出循环,continue会进行下一次循环
#include<iostream>
using namespace std;
#include<string>
int main()
{
//continue输出奇数
for (int i = 0; i <= 100; i++)
{
if (i % 2 == 0)
{
continue;//之后的代码不会执行,重新进行下一次循环
}
cout << i << endl;
}
system("pause");
return 0;
}
4.3.3.goto语句
作用:可以无条件跳转语句
语法:goto 标记;
解释:如果标记的名称存在,执行到goto语句时,会跳转到标记的位置
#include<iostream>
using namespace std;
#include<string>
int main()
{
//goto
cout << "这是第一句" << endl;
goto THIRD;
cout << "这是第二句" << endl;
THIRD:
cout << "这是第三句" << endl;
system("pause");
return 0;
}
5.数组
5.1概述
所谓数组,就是一个集合,里面存放了相同类型的数据元素
- 特点1:数组中的每个数据元素都是相同的数据类型
- 特点2:数组是由连续的内存位置组成的
5.2一维数组
5.2.1.一维数组定义方式
一维数组定义的三种方式:
- 数据类型 数组名[数组长度];
- 数据类型 数组名[数组长度] = {值1,值2,...};
- 数据类型 数组名[ ] = {值1,值2,...};
第二种方式,若没有全部填充值,则会自动补齐0
数组特点:放在一块连续的内存空间中,数组中每个元素都是相同数据类型
数组中下标是从0开始索引
数组命名规范与变量名一致 ,不要和变量重名
#include<iostream>
using namespace std;
#include<string>
int main()
{
//数据类型 数组名[数组长度];
int one[3];
one[0] = 1;
one[1] = 2;
one[2] = 3;
cout << one[1] << endl;//2
//数据类型 数组名[数组长度] = {值1,值2,...};
int two[3] = { 5,6,7 };
cout << two[1] << endl;//6
//数据类型 数组名[ ] = {值1,值2,...};
int three[] = { 7,8,9 };
cout << three[1] << endl;//8
system("pause");
return 0;
}
5.2. 2.一维数组数组名
一维数组名称的用途:
- 可以统计整个数组在内存中的长度 sizeof(arr)
- 可以获取数组在内存中的首地址 cout<<arr<<endl;
数组首地址与数组第一个元素的地址相同
数组名是常量,不可以进行赋值操作
#include<iostream>
using namespace std;
#include<string>
int main()
{
//一维数组名称的作用
int one[8] = { 52,3,96,4,555,62,14,1000 };
cout << "one数组占用内存大小" << sizeof(one) << endl;
cout << "one数组中每个元素占内存大小:" << sizeof(one[1]) << endl;
cout << "one数组共有元素" << sizeof(one) / sizeof(one[0]) << "个" << endl;
cout << "one数组的首地址:" << one << endl;//16进制
cout << "one数组的首地址:" << (int)one << endl;//(int)强制转换为10进制
cout << "one数组中第一个元素的地址:" <<(int) & one[0] << endl;//某个元素的地址用&
cout << "one数组中第二个元素的地址:" << (int)&one[1] << endl;
system("pause");
return 0;
}
例1:五只小猪称体重
在一个数组中记录了五只小猪的体重,如int arr[300,350,200,400,250];找出并打印最重的小猪体重。
#include<iostream>
using namespace std;
#include<string>
int main()
{
//五只小猪称体重
int arr[] = { 300,350,200,400,250 };
for (int i = 0; i < 4; i++)
{
int a = arr[i];
int b = arr[i + 1] <= a ? a: arr[i+1];
if (i == 3)
{
goto NEXT;
}
continue;
NEXT:
cout << "最重的那头猪是:" << b << endl;
}
system("pause");
return 0;
}
#include<iostream>
using namespace std;
#include<string>
int main()
{
//五只小猪称体重
int arr[] = { 300,350,200,400,250 };
int max = 0;
for (int i = 0; i < 5; 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;
#include<string>
int main()
{
//元素逆置
int arr[] = { 300,350,200,400,250 };
int m = arr[0];
arr[0] = arr[4];
arr[4] = m;
int n = arr[1];
arr[1] = arr[3];
arr[3] = n;
for (int i = 0; i < 5; i++)
{
cout << arr[i] << endl;
}
system("pause");
return 0;
}
#include<iostream>
using namespace std;
#include<string>
int main()
{
//元素逆置
int arr[] = { 300,350,200,400,250 };
int start = 0;
int end = sizeof(arr) / sizeof(arr[0]) - 1;
while (start<end)
{
int m = 0;
m = arr[start];
arr[start] = arr[end];
arr[end] = m;
start++;
end--;
}
for (int i = 0; i < 5; i++)
{
cout << arr[i] << endl;
}
system("pause");
return 0;
}
5.2.3.冒泡排序
作用:最常用的排序算法,对数组内元素进行排序
- 比较相邻的元素,如果第一个比第二个答,就交换他们两个
- 对每一对相邻元素做同样的工作,执行完毕后,找到第一个最大值
- 重复以上的步骤,每次比较次数-1,直到不需要比较
#include<iostream>
using namespace std;
#include<string>
int main()
{
//利用冒泡排序进行元素升序
int arr[] = { 6,9,3,5,8,2,7,1,4 };
cout << "未进行升序前:" << endl;
for (int i = 0; i < 9; i++)
{
cout << arr[i] << " ";
}
cout << endl;
for (int i = 0; i < 9 - 1; i++)//总共排序轮数为 元素个数-1
{
for (int j = 0; j < 9 - i - 1; j++)//每轮次数为 总个数-本次轮数-1
{
if (arr[j] > arr[j + 1])//如果前一个大于后一个,交换
{
int m = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = m;
}
}
}
cout << "升序后:" << endl;
for (int i = 0; i < 9; i++)
{
cout << arr[i] << " ";
}
cout << endl;
system("pause");
return 0;
}
5.3二维数组
二维数组就是在一维数组上,多加一个维度。
5.3.1.二维数组定义方式
二维数组定义的四种方式:
- 数据类型 数组名[行数][列数];
- 数据类型 数组名[行数][列数] = {{数据1,数据2},{数据3,数据4}};
- 数据类型 数组名[行数][列数] = {数据1,数据2,数据3,数据4};
- 数据类型 数组名[ ][列数] = {数据1,数据2,数据3,数据4};
建议:以上四种定义方式,利用第二种更加直观,提高代码的可读性
#include<iostream>
using namespace std;
#include<string>
int main()
{
//数据类型 数组名[行数][列数];
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 << "第一种" << endl;
for (int i = 0; i < 2; i++)
{
for (int j = 0; j < 3; j++)
{
cout << arr[i][j] << " ";
}
}
cout << endl;
//数据类型 数组名[行数][列数] = { {数据1,数据2},{数据3,数据4} };
int arr2[2][3] =
{
{1,2,3},
{4,5,6}
};
cout << "第二种" << endl;
for (int i = 0; i < 2; i++)
{
for (int j = 0; j < 3; j++)
{
cout << arr2[i][j] << " ";
}
}
cout << endl;
//数据类型 数组名[行数][列数] = { 数据1,数据2,数据3,数据4 };
int arr3[2][3] = { 1,2,3,4,5,6 };
cout << "第三种" << endl;
for (int i = 0; i < 2; i++)
{
for (int j = 0; j < 3; j++)
{
cout << arr3[i][j] << " ";
}
}
cout << endl;
//数据类型 数组名[][列数] = { 数据1,数据2,数据3,数据4 };
int arr4[][3] = { 1,2,3,4,5,6 };
cout << "第四种" << endl;
for (int i = 0; i < 2; i++)
{
for (int j = 0; j < 3; j++)
{
cout << arr4[i][j] << " ";
}
}
cout << endl;
system("pause");
return 0;
}
5.3.2.二维数组数组名
- 查看二维数组所占内存空间
- 获取二维数组首地址
#include<iostream>
using namespace std;
#include<string>
int main()
{
int arr[2][3] = {{1,2,3},{4,5,6}};
cout << "二维数组占用内存:" << 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;
cout << "二维数组的首地址:" <<(int) arr << endl;
cout << "二维数组第一行的首地址:" <<(int) arr[0]<< endl;
cout << "二维数组的第二个元素的地址:" << (int) &arr[0][1] << endl;
system("pause");
return 0;
}
5.3.3.二维数组应用案例
有三名同学(张三李四王五),在一次考试中的成绩分别如下表,请分别输出三名同学的总成绩
语文 | 数学 | 英语 | |
张三 | 100 | 100 | 100 |
李四 | 90 | 50 | 100 |
王五 | 60 | 70 | 80 |
#include<iostream>
using namespace std;
#include<string>
int main()
{
//二维数组应用案例
int arr[][3] = { {100,100,100},{90,50,100},{60,70,80} };//3*3
for (int i = 0; i < 3; i++)
{
int all = 0;
for (int j = 0; j < 3; j++)
{
all += arr[i][j];//all=all+arr[i][j]
}
switch (i)
{
case 0:
cout << "张三的总成绩是:" << all << endl;
break;
case 1:
cout << "李四的总成绩是:" << all << endl;
break;
case 2:
cout << "王五的总成绩是:" << all << endl;
break;
}
}
system("pause");
return 0;
}
#include<iostream>
using namespace std;
#include<string>
int main()
{
//二维数组应用案例
string name[3] = { "张三","李四","王五" };
int arr[][3] = { {100,100,100},{90,50,100},{60,70,80} };//3*3
for (int i = 0; i < 3; i++)
{
int all = 0;
for (int j = 0; j < 3; j++)
{
all += arr[i][j];//all=all+arr[i][j]
}
cout << name[i]<<"的总成绩是:" << all << endl;
}
system("pause");
return 0;
}
6.函数
6.1概述
作用:将一段经常使用的代码封装起来,减少重复代码
一个比较大的程序,一般分为若干个程序块,每个模块实现特定的功能
6.2函数的定义
函数的定义一般主要有五个步骤:
- 返回值类型:一个函数可以返回一个值,在函数定义中
- 函数名:给函数起个名称
- 参数列表:使用该函数时,传入的数据
- 函数体语句:花括号内的代码,函数内需要执行的语句
- return表达式 :和返回值类型挂钩,函数执行完后,返回相应的护具
语法:返回值类型 函数名 (参数列表)
{
函数体语句
return表达式
}
6.3函数的调用
功能:使用定义好的函数
语法: 函数名(参数)
#include<iostream>
using namespace std;
#include<string>
int Add(int num1, int num2)
{
int sum = num1 + num2;
return sum;
}
int main()
{
int num1 = 0;
int num2 = 0;
cout << "输入num1:";
cin >> num1;
cout << "输入num2:";
cin >> num2;
int sum =Add(num1, num2);
cout << "sum=" << sum << endl;
system("pause");
return 0;
}
6.4值传递
- 所谓值传递,就是函数调用时实参将数值传入给形参
- 值传递时,如果形参发生改变,并不会影响实参
#include<iostream>
using namespace std;
#include<string>
//值传递
//定义函数,实现两个数字进行交换函数
//如果函数不需要返回值,声明的时候可以写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;
swap(a, b);
system("pause");
return 0;
}
6.5函数的常见样式
常见的函数样式有四种
- 无参无返
- 有参无返
- 无参有返
- 有参有返
#include<iostream>
using namespace std;
#include<string>
//无参无返
void test01()
{
cout << "01" << endl;
}
//有参无返
void test02(int a)
{
cout << "02,a=" <<a<< endl;
}
//无参有返
int test03()
{
cout << "03" << endl;
return 10;
}
//有参有返
int test04(int a)
{
cout << "04,a=" <<a<< endl;
return 20;
}
int main()
{
//无参无返调用
test01();
//有参无返调用
test02(100);
//无参有返调用
int num1 = test03();
cout << "num1=" << num1 << endl;
//有参有返调用
int num2 = test04(30);
cout << "num2=" << num2 << endl;
system("pause");
return 0;
}
6.6函数的声明
作用:告诉编译器函数名称及如何调用函数,函数的实际主体可以单独定义
- 函数的声明可以多次,但是函数的定义只能有一次
定义函数在main函数之前,可以不声明,但是定义函数在main函数之后,必须声明函数
#include<iostream>
using namespace std;
#include<string>
//函数的声明
//比较函数,实现两个整型数字进行比较,返回较大的值
//提前告诉编译器函数存在,可以利用函数的声明
int max(int a, int b);//函数的声明
int main()
{
int a = 10;
int b = 20;
cout << "max=" << max(a, b) << endl;
system("pause");
return 0;
}
int max(int a, int b)
{
return a > b ? a : b;
}
6.7函数的分文件编写
作用:让代码结构更加清晰
函数分文件编写一般有四个步骤
- 创建后缀名为.h的头文件
- 创建后缀名为.cpp的源文件
- 在头文件中写函数的声明
- 在源文件中写函数的定义
在cpp文件中置顶写#include “xxxx.h”//双引号代表是自己定义的
在xxxx.h文件中还要写 #include<iostream>
using namespace std;
当前文件中只需要写#include“xxxx.h”,就可以使用分文件函数了
7.指针
7.1指针的基本概念
指针的作用:可以通过指针间接访问内存
- 内存编号是从0开始记录的,一般用十六进制数字表示
- 可以利用指针变量保存地址
7.2指针变量的定义和使用
指针变量定义语法:数据类型 * 变量名;
#include<iostream>
using namespace std;
#include<string>
int main()
{
//1.定义指针
int a = 10;
//指针定义的语法;数据类型 * 指针变量
int* p;
//让指针记录变量a的地址
p = &a;
cout << "a的地址:" << &a << endl;
cout << "指针p为:" << p << endl;
//2.使用指针
//可以通过解引用的方式来找到指针指向的内存
//解引用:指针前面加一个*
*p = 1000;//找到a的内存地址并修改值
cout << "a = " << a << endl;
cout << "*p = " << *p << endl;
system("pause");
return 0;
}
7.3指针所占内存空间
提问:指针也是一种数据类型,那么这种数据类型占用多杀内存空间?
在32位操作系统下,指针不管大小,占用四个字节,64位下占8个字节
#include<iostream>
using namespace std;
#include<string>
int main()
{
//指针所占的内存空间大小
int a = 10;
int* p = &a;
//32位操作系统下,不论数据类型,都是4字节
//64位操作系统下,不论数据类型,都是8字节
cout << "指针的大小:" << sizeof(int*) << endl;
cout << "指针的大小:" << sizeof(float*) << endl;
cout << "指针的大小:" << sizeof(double*) << endl;
cout << "指针的大小:" << sizeof(char*) << endl;
system("pause");
return 0;
}
7.4空指针和野指针
空指针:指针变量指向内存中编号为0的空间
用途:初始化指针变量
注意:空指针指向的内存是不可以访问的
0-255之间的内存编号是系统占用的,所以不可以访问
#include<iostream>
using namespace std;
#include<string>
int main()
{
//空指针
//1.空指针用于给指针变量进行初始化
int* p = NULL;//指向空
//2.空指针是不可以进行访问的
//0-255之间的内存编号是系统占用的,所以不可以访问
*p = 100;//会报错
system("pause");
return 0;
}
野指针:指针变量指向非法的内存空间
#include<iostream>
using namespace std;
#include<string>
int main()
{
//野指针
//在程序中需要避免出现野指针
int* p = (int*)0x1100;//指向一个非法的内存
cout << *p << endl;//崩了
system("pause");
return 0;
}
总结:空指针与野指针都不是我们申请的空间,因此不要访问
7.5const修饰指针
const修饰指针有三种情况:
- const修饰指针——常量指针
- const修饰常量——指针常量
- const即修饰指针,又修饰常量
常量指针: const int* p = &a;
特点:指针的指向可以修改,但是指针指向的值不可以改
指针常量:int* const p = &a;
特点:指针的指向不可以修改,但是指针指向的值可以改
const即修饰指针,又修饰常量:const int* const 拍= &a;
特点,指针指向的值和指针的指向都不可以改
巧记小妙招:const修饰*,那么*p就不能修改了,const修饰p,那么p就不能修改了。
#include<iostream>
using namespace std;
#include<string>
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指针和数组
作用:利用指针访问数组中元素
p[i]也可以用来访问数组中的元素,等同于arr[i]
#include<iostream>
using namespace std;
#include<string>
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++;//整数型指针,++之后就往后移了8个字节
cout << "利用指针来访问第二个元素:" << *p << endl;
for (int i = 2; i < 10; i++)
{
cout << "利用指针来访问第"<<i<<"个元素:" << *p << endl;
p++;
}
system("pause");
return 0;
}
7.7指针和函数
作用:利用指针作函数参数,可以修改实参的值
如果不想修改实参,就用值传递,如果想修改实参,就用地址传递
#include<iostream>
using namespace std;
#include<string>
//实现两个数字进行交换
void swap01(int a, int b)
{
int temp = a;
a = b;
b = temp;
cout << "值传递形参a=" << a << endl;
cout << "值传递形参b=" << b << endl;//值传递形参改变
}
void swap02(int* p1, int* p2)
{
int temp = *p1;
*p1 = *p2;
*p2 = temp;
cout << "地址传递形参*p1=" << *p1 << endl;
cout << "地址传递形参*p2=" << *p2 << endl;
}
int main()
{
//指针和函数
//1.值传递
int a = 10;
int b = 20;
swap01(a, b);
cout << "值传递实参a=" << a << endl;
cout << "值传递实参b=" << b << endl;//值传递实参不变
//2.地址传递
swap02(&a, &b);
cout << "地址传递实参a=" << a << endl;
cout << "地址传递实参b=" << b << endl;//地址传递可以改变实参值
system("pause");
return 0;
}
7.8指针、数组、函数
案例描述:封装一个函数,利用冒泡排序,实现对整型数组的升序排序
例如数组:int arr[10] = {4,3,6,9,1,2,10,8,7,5};
#include<iostream>
using namespace std;
#include<string>
//冒泡排序
void MaoPao(int*p,int len)//首地址与数组长度
{
for (int i = 0; i < len-1; i++)
{
for (int j = 0; j < len - i - 1; j++)
{
if (p[j] > p[j + 1])
{
int m = p[j];
p[j] = p[j + 1];
p[j + 1] = m;
}
}
}
cout << "升序后结果:";
for (int i = 0; i < 10; i++)
{
cout << *p<<" ";
p++;
}
cout << endl;
}
int main()
{
int arr[] = {4,3,6,9,1,2,10,8,7,5};
MaoPao(arr,sizeof(arr)/sizeof(arr[0]));
system("pause");
return 0;
}
8.结构体
8.1结构体基本概念
结构体属于用户自定义的数据类型 ,允许用户存储不同的数据类型
8.2结构体定义和使用
语法:struct 结构体名 {结构体成员列表};
通过结构体创建变量的方式有三种:
- struct 结构体名 变量名
- struct 结构体名 变量名 = {成员1值,成员2值,...}
- 定义结构体时顺便创建变量
struct定义时,关键字要写
struct创建时 关键字可以不写
赋值是通过.访问结构体变量汇总的属性
#include<iostream>
using namespace std;
#include<string>
//1.创建一个学生的数据类型:包括姓名,年龄,分数
//自定义数据类型,一些类型集合组成的一个类型
// 语法 struct 类型名称 {成员列表}
//结构体定义时,struct必须写
struct student
{
//成员列表
//姓名
string name;
//年龄
int age;
//分数
int score;
}s3; //顺便创建的结构体变量
//2.通过学生类型创建具体的学生
int main()
{
//2.1 struct student s1
//struct创建时 关键字可以不写
student s1;
//给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 = { "李四", 22, 80 };
cout << "姓名" << s2.name << "年龄" << s2.age << "分数" << s2.score << endl;
//2.3 定义结构体时顺便创建变量
s3.name = "王五";
s3.age = 32;
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>
//结构体数组
struct student//结构体
{
string name;//姓名
int age;//年龄
int score;//分数
};
int main()
{
//创建结构体数组
struct student arr[3] = { {"张三",18,100},{"李四",22,80},{"王五" ,32,60} };
arr[2].name = "赵六";//赋值更改数组元素
arr[2].age = 33;
for (int i = 0; i < 3; i++)
{
cout <<"姓名:"<< arr[i].name
<< " 年龄:"<<arr[i].age
<< " 分数:"<<arr[i].score << endl;
}
system("pause");
return 0;
}
8.4结构体指针
作用:通过指针访问结构体中的成员
- 利用操作符->可以通过结构体指针访问结构体属性
#include<iostream>
using namespace std;
#include<string>
//结构体指针
struct student
{
string name;//姓名
int age;//年龄
int score;//分数
};
int main()
{
//创建学生结构体变量
struct student s = { "张三",18,100 };
//通过指针指向结构体变量
//s的类型是struct student
struct student* p = &s;//struct可省略
//通过指针访问结构体变量中的数据
cout << "姓名:" << p->name//指针访问->
<< " 年龄:" << p->age
<< " 分数:" << p->score << 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 = 55;
t.stu.name = "小李";//嵌套需要两个.
t.stu.age = 22;
t.stu.score = 68;
cout << "teacher id:" << t.id
<< "\nteacher name:" << t.name
<< "\nteacher age:" << t.age
<< "\nstudent name:" << t.stu.name
<< "\nstuden age:" << t.stu.age
<< "\nstudent score:" << 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;//分数
};
//打印学生信息函数
//值传递 实参不会改变
void printstudent1(struct student s)
{
s.age = 100;
cout << "子函数1中打印 姓名:" << s.name << "年龄:" << s.age << "分数:" << s.score << endl;
}
//地址传递 实参会改变
void printstudent2(struct student* p)
{
p->score = 100;
cout << "子函数2中打印 姓名:" << p->name << "年龄:" << p->age << "分数:" << p->score << endl;
}
int main()
{
//结构体做函数的参数
//将学生传入到一个参数中打印学生的信息
//创建一个结构体变量
struct student s;
s.name = "张三";
s.age = 30;
s.score = 85;
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 score;
};
//将函数中的形参改为指针,可以减少内存空间,而且不会复制新的副本出来
//但是地址传递,形参改变,实参也会改变
//运用const可以避免误操作
void printstudents(const student *s)
{
//s->age = 150;加入const,一旦有修改操作就会报错
cout << "name:" << s->name << " age:" << s->age << " score:" << s->score << endl;
}
int main()
{
student s = { "张三",15,66 };
//通过函数打印结构体变量信息
printstudents(&s);
system("pause");
return 0;
}
8.8结构体案例
8.8.1案例1
学校正在做毕设项目,每名老师带领五个学生,总共有三名老师,需求如下:
设计学生和老师的结构体,其中在老师结构体中,有老师姓名和一个存放五名学生的数组作为成员学生的成员有姓名、考试分数,创建数组存放3名老师,通过函数给每个老师及所带的学生赋值,最终打印出老师数据以及老师所带的学生数据。
#include<iostream>
using namespace std;
#include<string>
#include<ctime>
//结构体案例1
struct student//学生结构体
{
string name;
int score;
};
struct teacher//老师结构体
{
string name;
struct student s[5];
};
void FUZHI(teacher *t, student *s)//函数体,参数可为teacher t[],student s[]
{
for (int i = 0; i < 3; i++)//循环老师命名
{
string ABCDE = "ABCDE";
t[i].name = "Teacher_";
t[i].name += ABCDE[i];
for (int j = 0; j < 5; j++)//循环学生命名
{
t[i].s[j].name = "Student_";
t[i].s[j].name += ABCDE[j];
int random = rand() % 100+1;//随机数1-100
t[i].s[j].score =random;//随机得分
}
}
for (int i = 0; i < 3; i++)//循环打印老师
{
cout << "老师:" << t[i].name << endl;
for (int j = 0; j < 5; j++)//循环打印学生
{
cout << "\t学生姓名:" << t[i].s[j].name
<< " 学生分数:" << t[i].s[j].score << endl;
}
}
}
int main()
{
srand((unsigned int)time(NULL)); //随机数种子
student s[5];//学生结构体变量
teacher t[3];//老师结构体变量
FUZHI(t,s);
system("pause");
return 0;
}
8.8.2案例2
设计一个英雄的结构体包括成员姓名,年龄,性别;创建结构体数组,数组中存放5名英雄,通过冒泡排序的方法,将数组中的英雄按年龄进行升序排序,最终 打印排序后的结果
#include<iostream>
using namespace std;
#include<string>
//结构体案例2
struct hero//定义结构体
{
string name;
int age;
string gender;
};
void MaoPao(hero H[], int len)//定义冒泡函数
{
for (int i = 0; i < len - 1; i++)
{
for (int j = 0; j < len - i - 1; j++)
{
if (H[j].age > H[j+1].age)
{
hero temp = H[j];//注意数据类型统一
H[j] = H[j + 1];
H[j + 1] = temp;
}
}
}
}
void printresult(hero H[],int len)//打印函数
{
for (int i = 0; i < len; i++)
{
cout << H[i].name <<" " <<H[i].age << " "<<H[i].gender << endl;
}
}
int main()
{
hero H[5] = {
{"刘备",23,"男"},
{"关羽",22,"男"},
{"张飞",20,"男"},
{"赵云",21,"男"},
{"貂蝉",19,"女"}
};
int len = sizeof(H) / sizeof(H[0]);
MaoPao(H,len);
printresult(H, len);
system("pause");
return 0;
}