文章详细介绍了C++的基础知识，包括变量、常量、数据类型、运算符、流程控制结构、数组、函数的定义与调用、指针的使用等。特别强调了指针在访问内存、数组和函数中的作用，以及如何通过指针进行内存操作和数据交换。此外，还提到了结构体的概念，包括结构体的定义、使用、嵌套以及作为函数参数的情况。
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++中能够表示类型的数据类型有以下几种方式，区别在于所占内存空间的不同：
数据类型 | 占用空间 | 取值范围 |
Short（短整型） | 2字节 | (-2^15~2^15-1） |
Int（整型） | 4字节 | (-2^31~2^31-1) |
Long（长整型） | Window下为4字节 linux为4字节（32位） 8字节（64位） | (-2^31~2^31-1) |
Long long（长长整型） | 8字节 | (-2^31~2^31-1) |
#include<iostream>
using namespace std;
int main()
{
//1.短整型short
short num1 = 10;
cout << "short(num1)所占内存空间的大小为：" << sizeof(short) << endl;
cout << "short(num1)所占内存空间的大小为：" << sizeof(num1) << endl;
//2.整型int
int num2 = 10;
cout << "int(num2)所占内存空间的大小为：" << sizeof(int) << endl;
cout << "int(num2)所占内存空间的大小为：" << sizeof(num2) << endl;
//3.长整型long
long num3 = 10;
cout << "long(num3)所占内存空间的大小为：" << sizeof(long) << endl;
cout << "long(num3)所占内存空间的大小为：" << sizeof(num3) << endl;
//4.长长整型long long
long 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实型（浮点型）
作用：用于表示小数
浮点型变量分为两种：
单精度float
双精度double
两者的区别在于表示数字有效范围不同
数据类型 | 占用空间 | 有效范围数字 |
Float | 4字节 | 7位有效数字 |
Double | 8字节 | 15-16位有效数字 |
3.14表示的是三位有效数字
#include<iostream>
using namespace std;
int main()
{
//1、单精度 float
float f1 = 3.1415926f;
cout << "f1= " << f1 << endl;
//2、双精度 double
double 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; //结果为97
system("pause");
return 0;
}*C和C++中字符型变量只占一个字节
*字符型变量并不是把字符本身放到内存中存储，而是将对应的ASC11码值放到存储单元。
2.5转义字符
作用：用于表示一些不能显示出来的ASC11字符
现阶段我们常用的转义字符有\n \\ \t
#include<iostream>
using namespace std;
int main()
{
//转义字符
//换行符 \n
cout << "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; //1
flag = false;
cout << flag << endl; //0
//2.查看bool类型所占内存空间的大小
cout << "布尔类型所占内存空间的大小为：" << sizeof(bool) << endl; //1
system("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算数运算符
作用：用于处理四则运算
算数运算符包括以下符号：
运算符 | 术语 | 示例 | 结果 |
+ | 正号 | +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 |
#include<iostream>
using namespace std;
int main()
{
//加减乘除
int a1 = 10;
int b1 = 3;
cout << "a + b = " << a1 + b1 << endl; //13
cout << "a - b = " << a1 - b1 << endl; //7
cout << "a * b = " << a1 * b1 << endl; //30
cout << "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; //6
cout << "b4 = " << b4 << endl; //60
int a5 = 5;
int b5 = a5++ * 10;
cout << "a5 = " << a5 << endl; //6
cout << "b5 = " << b5 << endl; //50
system("pause");
return 0;
}3.2赋值运算符
作用：用于将表达式的值赋给变量
赋值运算符包括以下几个符号
运算符 | 术语 | 示例 | 结果 |
= | 赋值 | a=2;b=3 | a=2;b=3; |
+= | 加等于 | a=0;b++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 |
#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; //5
system("pause");
return 0;
}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;
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; //1
system("pause");
return 0;
}3.4逻辑运算符
作用：用于根据逻辑表达式的值返回真值或假值
逻辑运算符有以下符号：
运算符 | 术语 | 示例 | 结果 |
！ | 非 | ！a | 如果a为假，则！a为真；反之 |
&& | 与 | a&&b | 如果a和b都为真，则结果为真，否则为假 |
|| | 或 | a||b | 如果a和b有一个为真，结果为真，二者都为假，结果才为假 |
#include<iostream>
using namespace std;
int main()
{
//逻辑运算符 非
int a = 10;
//在c++中除了0 都为真
cout << !a << endl; //0
cout << !!a << endl; //1
//逻辑运算符 与
//同真为真，其余为假，零零为假
int b = 10;
int c = 10;
cout << (b && c) << endl; //1
b = 0;
c = 10;
cout << (b && c) << endl; //0
b = 0;
c = 0;
cout << (b && c) << endl; //0
//逻辑运算符 或
//同假为假，其余为真
int d = 10;
int e = 10;
cout << (d || e) << endl; //1
d = 0;
e = 10;
cout << (d || e) << endl; //1
d = 0;
e = 0;
cout << (d || e) << endl; //0
system("pause");
return 0;
}四.程序流程结构
C/C++支持最基本的三种程序运行结构：顺序结构、选择结构、循环结构。
顺序结构：程序按照顺序执行，不发生跳转。
选择结构：依据条件是否满足，有选择的执行相应的功能。
循环结构：依据条件是否满足，循环多次执行某段代码。
4.1选择结构
if语句
作用：执行满足条件的语句
If语句的三种表现形式
单行格式if语句
多行格式if语句
多条件的if语句
单行格式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;
}多行格式if语句：if（条件）{条件满足执行的预计}else{条件不满足执行的语句}
多条件的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做比较，将变量大的值赋给变量c
int 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=10
cout << "b= " << b << endl; //b=100
system("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打印到数字9
for (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.值2.......}
数据类型 数组名[ ]={值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;
}一维数组数组名
一维数组名称的用途：
可以统计整个数组在内存中所占的长度
可以获取数组在内存中的首地址
#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;
//开始冒泡排序
//排序的总轮数=元素个数-1
for (int i = 0; i < 9 - 1; i++)
{
//内层循环对比 次数=元素个数-当前轮数-1
for (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，数据2} },{ {数据3，数据4} };
数据类型数组名[行数] [列数]={数据1，数据2，数据3，数据4};
数据类型数组名[] [列数]={数据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;
//转为十进制加int
cout << "二维数组的首地址为 " << (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;
}
维数组应用的案例
考试成绩统计：
案例描述：有三名同学（张三，李四，王五），在一次考试中的成绩如下表，请分别输出三名同学的总成绩
语文 | 数学 | 英语 | |
张三 | 100 | 100 | 100 |
李四 | 90 | 50 | 100 |
王五 | 60 | 70 | 80 |
#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个步骤：
返回值类型
函数名
参数列表
函数体语句
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种
无参无返
有参无返
无参有返
有参有返
#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个步骤
创建后缀名为.h的头文件
创建后缀名为.cpp的源文件
在头文件中写函数的声明
在源文件中写函数的定义
这个需要自己看视频。来加强自己的认知。
七.指针
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修饰指针有三种情况：
const修饰指针 ......常量指针
Const修饰常量 ......指针常量
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 s1
struct 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~100
tArray[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;
}
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
