配套视频：
https://www.bilibili.com/video/BV1et411b73Z
为方便个人学习，在此发布C++基础入门部分配套讲义（以下均为个人总结），原作者为黑马程序
如存在问题，请大家在评论区留言，谢谢。欢迎大家共同学习，一起进步。

1 C++初识

1.4 常量

//常量：用于记录程序中不可更改的数据
//1、#define 宏常量：#define 常量名 常量值
//通常定义在文件上方，表示一个常量
//2、const修饰的变量 ：const 数据类型 常量名 = 常量值
//通常在变量定义前加关键字const，修饰改变量为常量，不可修改

#include<iostream>
using namespace std;
//1、#define 宏常量：
#define Day 7
int main() {
//Day = 14;
//错误：Day是常量，不可修改
cout << "一周有 " << Day <<"天" << endl;
//2、const修饰的变量 
const int month = 12;
//month = 24;
//错误：const修饰的变量也是不可修改
cout << "一年总共有" << month << "月" << endl;
system("pause");
return 0;
}

1.5 关键字

关键字：在c++中预先保留的单词，给变量或常量起名时，再次使用会有歧义
创建变量：数据类型 变量名称 = 变量初始值
不要用关键字给变量或者常量起名字
int int = 10; //错误：第二个int 是关键字 ，不可以作为变量名称

1.6 标识符命名规则

1. 标识符不可以是关键字
2. 标识符是由字母、数字、下划线组成
3. 标识符第一个字符只能是字母或下划线
4. 标识符是区分大小写的

2 数据类型

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

2.1 整型

C++中能够表示整型的类型有以下几种，区别在于内存空间不同：

2.2 sizeof关键字

sizeof关键字：统计数据类型所占内存大小
语法：sizeof（数据类型/变量）

#include<iostream>
using namespace std;
int main() {
short num1 = 10;
cout << "short所占内存大小：" << sizeof(num1) << endl;
cout << "short所占内存大小：" << sizeof(short) << endl;
int a = 10;
cout << "int所占内存大小：" << sizeof(int) << endl;
cout << "a 所占内存大小：" << sizeof( a ) << endl;
cout << "long所占内存大小：" << sizeof(long) << endl;
cout << "long long 所占内存大小：" << sizeof(long long) << endl;
system("pause");
return 0;
}

2.3 实型（浮点型）

//实型（浮点型）：用于表示小数
//1、单精度 float 4个字节 7位有效数字
//2、双精度 double 8个字节 15~16位有效数字
//两者表示有效数字范围不同

//默认情况下 输出一个小数，会显示6位有效数字

#include<iostream>
using namespace std;
int main() {
float f1 = 3.1415926f;
//否则默认双精度
double d1 = 3.14;
double d2 = 3.141592653;
double d3 = 3.14159265354579;
cout << "f1= " << f1 << endl;
cout << "d1= " << d1 << endl;
cout << "d2= " << d2 << endl;
cout << "d3= " << d3 << endl;
//统计float 和double占用内存空间
cout << "float 占用内存空间：" << sizeof(float) << endl;
//4字节
cout << "double占用内存空间：" << sizeof(double) << endl; //8字节
//科学计数法
float f2 = 3e2; //3* 10 ^2
float f3 = 3e-2; //3* 0.1 ^2
cout << "f2=" << f2 << endl;
cout << "f3=" << f3 << endl;
system("pause");
return 0;
}

2.4 字符型

字符型：显示单个字符
语法：char ch = 'a‘；
注意： 1）在显示字符型变量时，用单引号将字符括起来，不要用双引号
2）单引号内只能有一个字符，不可以是字符串
字符型变量只占用一个字节

#include<iostream>
using namespace std;
int main()
{
//1、字符型变量创建方式
char ch = 'a';
cout << "ch= " << ch << endl;
//2、字符型变量所占内存大小
cout << "char所占内存大小为：" << sizeof(char) << endl;
//3、字符型变量常见错误
//char ch2 = "b";
//注意用单引号
//char ch3 = 'abc'
//注意单个字符
//4、字符型变量对应ASCII编码
cout <<(int) ch << endl;
//a 对应的ASCII是 97
字符型强转为整型
char ch1 = 'A';
cout << (int)ch1 << endl;
//A 对应的ASCII是 65
system("pause");
return 0;
}

2.5 转义字符

#include<iostream>
using namespace std;
int main() {
//
换行
n

cout << "hello world n";
//
反斜杠
\ 
cout << "\" << endl;
//
水平制表符
t
cout << "aaaaaahelloworld n" ;
cout << "aaa t helloworld n" ;//一共8个宽度，作用：对齐输出
cout << "aaaaaaaahelloworld n" ;
system("pause");
return 0;
}

2.6 字符串型

字符串：表示一串字符
c++风格 string

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

2.7 布尔类型

布尔类型bool–布尔类型代表真或假的值
true–真（本质是1）
false–假（本质是0）

#include<iostream>
using namespace std;
int main() {
//1、创建bool数据类型
bool flag = true;
cout << flag << endl; //1
flag = false;
cout << flag << endl;
//0
//2、查看bool
cout << "bool类型所占内存空间" << sizeof(bool) << endl; //1
system("pause");
return 0;
}

2.8 数据的输入

数据的输入：用于从键盘获取数据
关键字：cin
语法：cin >> 变量

#include<iostream>
using namespace std;
int main() {
//1、整型输入
int a = 0;
cout << "请给整型变量a赋值：" << endl;
cin >> a;
cout << "整型变量a = " << a << "n";
//2、浮点型输入
float f = 3.14f;
cout << "请给浮点型变量f赋值：" << endl;
cin >> f;
cout << "浮点型变量f=" << f << endl;
//3、字符型输入
char ch = 'a';
cout << "请给字符型变量ch赋值：" << endl;
cin >> ch;
cout << "字符型变量ch=" << ch << endl;
//4、字符串型输入
string str = "abc";
cout << "请给字符串型变量str赋值：n";
cin >> str;
cout << "字符串变量str=" << str << endl;
//5、bool型输入(bool类型除了非0的值都代表真)
bool flag = true;
cout << "请给bool类型赋值：n";
cin >> flag;
cout << "bool型flag=" << flag << endl;
system("pause");
return 0;
}

3 运算符

作用：执行代码运算

3.1 算术运算符

3.1.1 加减乘除

#include<iostream>
using namespace std;
int main() {
//加减乘除
int a1 = 10;
int b1 = 3;
cout << a1 + b1 << endl;
cout << a1 - b1 << endl;
cout << a1 * b1 << endl;
cout << a1 / b1 << endl;
//两个数整除，结果依然是整数，将小数部分去除
int a2 = 10;
int b2 = 20;
cout << a2 / b2 << endl;
//int a3 = 10;
//int b3 = 0;
//cout << a3 / b3 << endl;
//0不可以是被除数
system("pause");
return 0;
}

3.1.2 取模

#include<iostream>
using namespace std;
int main() {
//取模运算的本质是取余数
int a1 = 10;
int b1 = 3;
cout << a1 % b1 << endl;
int a2 = 10;
int b2 = 20;
cout << a2 % b2 << endl;
//两个小数不可以做取模运算
system("pause");
return 0;
}

3.1.3 递增递减

#include<iostream>
using namespace std;
int main() {
//1、前置递增
int a = 10;
++a;
cout << "a=" << a << endl;
//2、后置递增
int b = 10;
b++;
cout << "b=" << b << endl;
//3、前值和后置区别
//前置递增 先让变量+1
然后进行表达式运算
int a2 = 10;
int b2 = ++a2 * 2;
cout << "b2=" << b2 << endl;
//后置递增 先让进行表达式运算
然后在+1
int a3 = 10;
int b3 = a3++ * 2;
cout << "a3=" << a3 << endl;
cout << "b3=" << b3 << endl;
int a4 = 10;
int c3 = a4++ * 2;
int c4 = a4++ * 2;
int c2 = ++a4 * 2;
cout << "c2=" << c2 << endl;
cout << "a4=" << a4 << endl;
cout << "c3=" << c3 << endl;
cout << "c4=" << c4 << endl;
cout << "a4=" << a4 << endl;
system("pause");
return 0;
}

3.2 赋值运算符

#include<iostream>
using namespace std;
int main() {
//赋值运算
// =
int a = 10;
a = 100;
cout << "a=" << a << endl;
// +=
a = 10;
a += 2 ;
cout << "a=" << a << endl;
// -=
a = 10;
a -= 2;
cout << "a=" << a << endl;
// *=
a = 10;
a *= 2;
cout << "a=" << a << endl;
// /=
a = 10;
a /= 2;
cout << "a=" << a << endl;
// %=
a = 10;
a %= 2;
cout << "a=" << a << endl;
system("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; // 1
system("pause");
return 0;
}

3.4 逻辑运算符

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

3.4.1 非

int main() {
int a = 10;
cout << !a << endl; // 0
cout << !!a << endl; // 1
system("pause")
return 0;
}

3.4.2 与

同真为真，其余为假

//逻辑运算符
--- 与
#include<iostream>
using namespace std;
int main() {
int a = 10;
int b = 10;
cout << (a && b) << endl;// 1
a = 10;
b = 0;
cout << (a && b) << endl;// 0 
a = 0;
b = 0;
cout << (a && b) << endl;// 0
system("pause");
return 0;
}

3.4.3 或

全假为假，其余为真

//逻辑运算符
--- 或
#include <iostream>
using namespace std;
int main() {
int a = 10;
int b = 10;
cout << (a || b) << endl;// 1
a = 10;
b = 0;
cout << (a || b) << endl;// 1 
a = 0;
b = 0;
cout << (a || b) << endl;// 0
system("pause");
return 0;
}

4 程序流程结构

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

• 顺序结构：程序按顺序执行，不发生跳转
• 选择结构：一句条件是否满足，有选择地执行相应功能
• 循环结构：一句条件是否满足，循环多次执行某段的代码

4.1 选择结构

4.1.1 if语句

作用：执行满足条件的语句
三种形式：

• 单行格式
• 多行格式
• 多条件

4.1.1.1 单行格式if语句

if条件后面不要加分号

#include<iostream>
using namespace std;
int main() {
//用户输入分数，如果分数大于600，是为考上一本，在屏幕上输出
//1、用户输入分数
int score = 0;
cout << "请输入一个分数：" << endl;
cin >> score;
//2、打印用户输入信息
cout << "您输入的分数是：" << score << endl;
//3、判断分数是否大于600，如果大于，输出恭喜
if (score > 600)
{
cout << "恭喜您考上一本大学" << endl;
}
system("pause");
return 0;
}

4.1.1.2 多行格式if语句

#include<iostream>
using namespace std;
int main() {
int score = 0;
cout << "请输入考试分数：" << endl;
cin >> score;
if (score > 600)
{
cout << "我考上了一本大学" << endl;
}
else
{
cout << "我未考上一本大学" << endl;
}
system("pause");
return 0;
}

4.1.1.3 多条件if语句

#include<iostream>
using namespace std;
int main() {
//选择结构
多条件语句
//输入一个考试分数，如果大于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;
}

4.1.1.4 if嵌套

//案例需求：
//提示用户输入一个高考考试分数，根据分数做如下判断
//分数如果大于600分视为考上一本，大于500分考上二本，大于400考上三本，其余视为未考上本科；
//在一本分数中，如果大于700分，考入北大，大于650分，考入清华，大于600考入人大。
#include<iostream>
using namespace std;
int main() {
//1、提示输入高考分数
int score = 0;
cout << "请输入您的分数：" << endl;
cin >> score;
//2、显示输入高考分数
cout << "你输入的分数是：" << score << endl;
//3、判断
//如果大于600，一本
//大于700，清华
//大于650，北大
//其余人大
//如果大于500，二本
//如果大于400，三本
//	其余情况，未考上本科
if (score > 600)
{
cout << "恭喜您考上一本" << endl;
if (score > 700)
{
cout << "恭喜您考上清华大学" << endl;
}
else if (score > 650)
{
cout << "恭喜您考上北大" << endl;
}
else
{
cout << "恭喜您考上人大" << endl;
}
}
else if (score > 500)
{
cout << "恭喜您考上一本大学" << endl;
}
else if(score > 400)
{
cout << "恭喜您考上二本大学" << endl;
}
else
{
cout << "您未考上本科，再接再厉" << endl;
}
system("pause");
return 0;
}

4.1.1.5 案例：三只小猪

//练习案例： 三只小猪称体重
//有三只小猪ABC，请分别输入三只小猪的体重，并且判断哪只小猪最重？
#include<iostream>
using namespace std;
int main() {
//1、提示
int A = 0;
int B = 0;
int C = 0;
//2、让用户输入三只小猪的重量
cout << "请输入小猪A的重量" << endl;
cin >> A;
cout << "请输入小猪B的重量" << endl;
cin >> B;
cout << "请输入小猪C的重量" << endl;
cin >> C;
//3、判断哪只最重
if (A > B)
{
if (A > C)
{
cout << "A小猪最重" << endl;
}
else
{
cout << "C小猪最重" << endl;
}
}
else
{
if (B > C)
{
cout << "B小猪最重" << endl;
}
else
{
cout << "C小猪最重" << endl;
}
}
system("pause");
return 0;
}

4.1.2 三目运算符

作用：通过三目运算符实现简单的判断
语法：表达式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++中三目运算符返回的是变量，可以继续赋值
(a < b ? a : b) = 100;
cout << "a=" << a<< endl;
cout << "b=" << b << endl;
system("pause");
return 0;
}

4.1.3 switch语句

#include<iostream>
using namespace std;
//if 和switch 区别：
//switch 缺点：判断的时候只能是整型或者字符型，不可以是一个区间
//
优点：结构清晰，执行效率高
//case里面如果没有break会一直向下执行
int main() {
//请给电影评分 
//10 ~ 9
经典

// 8 ~ 7
非常好
// 6 ~ 5
一般
// 5分以下 烂片
int score = 0;
cout << "请给电影打分" << endl;
cin >> score;
cout << "您打的分数为：" << score << endl;
switch (score)
{
case 10:
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;
break;
}
system("pause");
return 0;
}

4.2 循环结构

4.2.1 while循环语句

作用： 满足循环条件，执行循环语句
语法：while(循环条件) { 循环语句 }
解释：只要循环条件的结果为真，就执行循环语句

#include<iostream>
using namespace std;
int main() {
//while循环
//打印0~9 10个数字
int num = 0;
while (num < 10)
{
cout << num << endl;
num++;
}
system("pause");
return 0;
}

4.2.1.1 案例：猜数字

//添加随机种子 作用利用当前系统时间生成随机数，防止每次随机数都一样
#include
srand((unsigned int)time(NULL));

int num = rand() % 100 + 1 ; //随机生成 1~100随机数

#include<iostream>
using namespace std;
//time系统时间头文件包含
#include <ctime>
int main() {
//添加随机种子 作用利用当前系统时间生成随机数，防止每次随机数都一样
srand((unsigned int)time(NULL));
//1、系统生成随机数
int num = rand() % 100 + 1 ; //随机生成 1~100随机数
//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;
}

4.2.2 do…while循环语句

分开比较

#include<iostream>
using namespace std;
int main() {
//do...while
//在屏幕上输出10个数
int num = 0;
//do {
//	cout << num << endl;
//	num++;
//} 
//while (num < 10);
//do while 和while区别：前者先执行一次循环，在判断循环条件
//比较1
和 2的区别
1
//while (num )
//{
//	cout << num << endl;
//	num++;
//}
// 此时 num = 0 条件为假
输出为空
1.1
//while (++num )
//{
//	cout << num << endl;
//
//}
// 此时一开始 num = 1 条件为真
一直输出
2
//do {
//	cout << num << endl;
//	num++;
//} 
//while (num );
//此时 num = 1 条件为真
一直循环下去
2.1
//do {
//	cout << num << endl;
//	
//} while (++num);
//此时num =1 条件为真 一直循环下去
2.2
//do {
//	cout << num << endl;
//} while (num++);
//此时num =0 条件为假 
system("pause");
return 0;
}

4.2.2.1 案例：水仙花数

#include<iostream>
using namespace std;
//水仙花数
int main() {
//1、先打印所有三位数字
int num = 100;
do
{
//2、从所有三位数中找到水仙花数
int a = 0;
//各位
int b = 0;
//十位
int c = 0;
//百位
a = num % 10;
//获取个位
b = num / 10 % 10;
//获取十位
c = num / 100;
//获取百位
if (num == a * a * a + b * b * b + c * c * c)
{
cout << num << endl;
}
num++;
} while (num < 1000);
system("pause");
return 0;
}

4.2.3 for循环语句

//for循环：满足循环条件，执行循环语句
//语法：for（起始表达式；条件表达式；末未循环体）{循环语句}
#include<iostream>
using namespace std;
int main() {
//从0打印到9
for (int i = 0; i < 10; i++)
//分号分割
{
cout << i << endl;
}
system("pause");
return 0;
}

4.2.3.1 案例：敲桌子

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

4.2.4 嵌套循环

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

4.2.3.1 案例：乘法表

//练习案例：九九乘法口诀表
//案例描述：利用嵌套循环，实现九九乘法表
#include<iostream>
using namespace std;
int main() {
for (int i = 1; i < 10; i++)
{
for (int j = 1; j <= i; j++)
{
cout << j << "*" << i << " = " << i * j <<"
" ;
}
cout << endl;
}
system("pause");
return 0;
}

4.3 跳转语句

4.3.1 break语句

//break作用：用于跳出选择结构 或 循环结构
//出现时机：1）出现在switch语句中，作用是终止case并跳出switch
//
2）出现在循环语句中，作用是跳出当前循环
//
3）出现在嵌套循环中，跳出最近的循环语句
#include<iostream>
using namespace std;
int main()
{
//1、在switch 语句中使用
//cout << "请选择您挑战副本的难度：" << endl;
//cout << "1、普通" << endl;
//cout << "2、中等" << endl;
//cout << "3、困难" << endl;
//int num = 0;
//创建一个选择结果
//cin >> num;
//等待用户输入
//switch (num)
//{
//case 1:
//	cout << "您选择的是普通难度" << endl;
//	break;
//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;
//0 1 2 3 4
}
//3、出现在嵌套循环语句中
for (int i = 0; i < 10; i++)
{
for (int j = 0; j < 10; j++)
{
if (j == 5)
{
break;
}
cout << "*" ;
}
cout << endl;
}
system("pause");
return 0;
}

4.3.2 continue语句

//**作用：continue在循环语句中，跳过本次循环中余下尚未执行的语句，继续执行下一次循环
//
break退出循环，结束
#include<iostream>
using namespace std;
int main()
{
for (int i =1; i < 100; i++)
{
if (i % 2 == 0)
//打印奇数
{
continue;
//跳过下面循环，重头开始执行
}
cout << i << endl;
//1 3 5 7 ...
}
system("pause");
return 0;
}

4.3.3 goto语句

//goto语句：无条件跳转语句
//goto语法；goto标记
//解释：如果标记的名称存在，执行goto语句时，会跳转标记位置
#include<iostream>
using namespace std;
int main()
{
cout << "1" << endl;
goto FLAG;
cout << "2" << endl;
cout << "3" << endl;
cout << "4" << endl;
FLAG:
cout << "5" << endl;
system("pause");
return 0;
}

5 数组

5.1 概述

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

特点1：数组中的每个数据元素都是相同的数据类型
特点2：数组是由连续的内存位置组成的

5.2 一维数组

5.2.1 一维数组定义方式

#include<iostream>
using namespace std;
int main()
{
定义方式1
数据类型 数组名[元素个数];
//int score[10];
利用下标赋值
//score[0] = 100;
//score[1] = 99;
//score[2] = 85;
利用下标输出
//cout << score[0] << endl;
//cout << score[1] << endl;
//cout << score[2] << endl;
第二种定义方式
数据类型 数组名[元素个数] =
{值1，值2 ，值3 ...};
如果{}内不足10个数据，剩余数据用0补全
//int score2[10] = { 100, 90,80,70,60,50,40,30,20,10 };
逐个输出
cout << score2[0] << endl;
cout << score2[1] << endl;
一个一个输出太麻烦，因此可以利用循环进行输出
//for (int i = 0; i < 10; i++)
//
//	cout << score2[i] << endl;
//}
//定义方式3
//数据类型 数组名[] =
{值1，值2 ，值3 ...};
int score3[] = { 100,90,80,70,60,50,40,30,20,10 };
for (int i = 0; i < 10; i++)
{
cout << score3[i] << endl;
}
system("pause");
return 0;
}

5.2.2 一维数组数组名

//一维数组名称的用途：
//1）可以统计整个数组在内存中的长度
//2）可以获取数组在内存中的首地址
#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;
//40
cout << "每个数组占用内存空间为：" << sizeof(arr[0]) << endl;
//4
cout << "整组中共有元素个数：" << sizeof(arr) / sizeof(arr[0]) << endl;
//10
//2、可以通过数组名查看数组首地址
cout << "数组首地址为：" << arr << endl;
//结果为16进制
cout << "数组首地址为：" << (int)arr << endl;
//强转为10进制
cout << "数组中第一个元素地址为：" << (int)&arr[0] << endl;
cout << "数组中第一个元素地址为：" << (int)&arr[1] << endl;
//数组名是常量，不可以进行赋值操作
//arr = 100;
system("pause");
return 0;
}

5.2.2.1 案例：五只小猪称体重

#include<iostream>
using namespace std;
int main() {
int arr[] = { 100,200,350,300,201 };
int max = 0;
for (int i = 0; i < 5; i++)
{
if (arr[i] > max)
{
max = arr[i];
}
}
cout << "最重小猪体重："<< max << endl;
system("pause");
return 0;
}

5.2.2.2 案例：元素逆置

//元素逆置--声明一个5个元素的数组，并且将元素逆置
//如：原数组元素为：1,3，2，5，4
逆置后输出结果为4,5,2,3,1
#include<iostream>
using namespace std;
int main() {
int arr[] = { 1,3,2,5,4 };
cout << "数组逆置前" << endl;
for (int i = 0; i < 5; i++)
{
cout << arr[i] << 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 < 5; i++)
{
cout << arr[i] << endl;
}
system("pause");
return 0;
}

5.2.3 冒泡排序

//冒泡排序
//作用： 最常用的排序算法，对数组内元素进行排序
//比较相邻的元素。如果第一个比第二个大，就交换他们两个。
///对每一对相邻元素做同样的工作，执行完毕后，找到第一个最大值。
//重复以上的步骤，每次比较次数 - 1，直到不需要比较
#include<iostream>
using namespace std;
int main() {
int arr[9] = { 2,4,0,5,7,1,3,8,9 };
for (int i = 0; i < 9 - 1; i++)
{
for (int j = 0; j < 9 - 1 - i; j++)
{
if (arr[j] > arr[j + 1])
{
int temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
for (int i = 0; i < 9; i++)
{
cout << arr[i] << 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;
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;
//外层循环打印行数，内层循环打印列数
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;
}
//3、数据类型 数组名[
][列数] = { 数据1，数据2，数据3，数据4 };
system("pause");
return 0;
}

5.3.2 二维数组数组名

#include<iostream>
using namespace std;
int main() {
//二维数组名称用途
//1、可以查看占用内存空间大小
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;
//2、可以查看二维数组的首地址
cout << "二维数组首地址：" << arr << endl;
cout << "二维数组第一行地址：" << arr[0] << endl;
cout << "二维数组第二行地址：" << arr[1] << endl;
cout << "二维数组第一个元素的地址：" << &arr[0][0] << endl;
cout << "二维数组第二个元素地址为：" << &arr[0][1] << endl;
system("pause");
return 0;
}

5.3.3 案例：考试成绩

#include<iostream>
using namespace std;
#include<string>
int main() {
//二维数组案例-考试成绩统计
//1、创建二维数组
int scores[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 += scores[i][j];
}
cout << names[i]<< "的总分为：" << sum << endl;
}
system("pause");
return 0;
}

6 函数

6.1 概述

**作用：**将一段经常使用的代码封装起来，减少重复代码
一个较大的程序一般分为若干个程序块，每个模块实现特定的功能

6.2 函数的定义

• 返回值类型:一个函数可以返回一个值，在函数定义中
• 函数名：给函数起个名称
• 参数列表：使用该函数时，传入的数据
• 函数体语句：花括号内的代码，函数内需要执行的语句
• return表达式：和返回值类型挂钩，函数执行完后，返回相应的数据

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

6.3 函数的调用

语法：函数名（参数）

#include<iostream>
using namespace std;
//加法函数
实现两个两个整型相加，并且将相加的结果进行返回
int add(int num1, int num2)
//num1 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;
//30
a = 100;
b = 200;
c = add(a, b);
cout << "c=" << c << endl;
//300
system("pause");
return 0;
}

6.4 值传递

• 函数调用时实参将数值传入给形参
• 值传递时，如果形参发生改变，不会影响实参

return;//返回值不需要的时候可以不写return

#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;
//10
cout << "b=" << b << endl;
//20
//当我们做值传递的时候，函数的形参发生改变，并不会影响实参
swap(a, b);
cout << "a=" << a << endl;
//10
cout << "b=" << b << endl;
//20
system("pause");
return 0;
}

6.5 函数的常见样式

#include<iostream>
using namespace std;
//函数常见样式
//1、无参无返
void test01()
{
cout << "this is test01" << endl;
//this is test01
}
//2、有参无返
void test02(int a)
{
cout << "this is test02 a= " << a << endl;
//this is test02 a= 100
}
//3、无参有返
int test03()
{
cout << "this is test03"
<< endl;
//this is test03
return 10;
}
//4、有参有返
int test04(int b)
{
cout << "this is test04 b=" <<b<< endl;
//this is test04 b=10000
return b;
}
int main() {
//无参无返函数调用
test01();
//有参无返函数调用
test02(100);
//无参有返函数调用
int c = test03();
cout << "c=" << c << endl;
//c=10
//有参有返函数调用
int num2 = test04(10000);
cout << "num2=" << num2 << endl;
//num2=10000
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后缀名头文件
• 2、创建.cpp后缀名的源文件
• 3、在头文件中写函数的声明
• 4、在源文件中写函数的定义

swap.h头文件

#include<iostream>
using namespace std;
//函数的声明
void swap(int a, int b);

#include<iostream>
using namespace std;
#include "swap.h"
函数的声明
//void swap(int a, int b);
//
函数的定义
//void swap(int a, int b)
//{
//	int temp = a;
//	a = b;
//	b = temp;
//
//	cout << "a= " << a << endl;
//	cout << "b=" << b << endl;
//}
int main() {
int a = 10;
int b = 20;
swap(a, b);
system("pause");
return 0;
}

#include"swap.h"
//双引号代表自定义头文件
//函数的定义
void swap(int a, int b)
{
int temp = a;
a = b;
b = temp;
cout << "a= " << a << endl;
cout << "b=" << b << endl;
}

7 指针

7.1 指针的基本概念

指针的作用：可以通过指针简介访问内存

• 内存编号是从0开始记录的，一般用十六进制数字表示
• 可以利用指针变量保存地址

7.2 指针变量的定义和使用

指针定义语法：数据类型 * 指针变量名 int*p;
p = &a; //& 取址符号
通过p可以找到a所在的内存 并且通过*p修改这个内存

*p指向数据对应的地址
p代表这个数据，可以修改

#include<iostream>
using namespace std;
int main() {
//1、定义指针
int a = 10;
//指针定义语法：数据类型 * 指针变量名
int*p;
//让指针记录变量a的地址

p = &a;
//& 取址符号
cout << "a的地址为：" << &a << endl;
//十六进制
cout << "a的地址为：" << (int)&a << endl;
//强转为十进制
cout << "指针p为：" << (int)p << endl;
//和上面结果相同，所以指针就是地址
//2、使用指针
//可以通过解引用的方式来找到指针指向的内存
//指针前加 * 代表解引用，找到指针指向的内存中的数据
*p = 1000;
//p前面加个*代表找到了p指向的内存中的数据
cout << "a=" << a << endl;
//1000
通过p可以找到a所在的内存 并且通过*p修改这个内存
cout << "*p=" << *p << endl;
//1000
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;
//整型指针
cout << "sizeof(int *)=" << sizeof(p) << endl;
//同上
cout << "sizeof(int *)=" << sizeof(float *) << endl;
cout << "sizeof(int *)=" << sizeof(double *) << endl;
cout << "sizeof(int *)=" << 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； //报错，可以指向，但不可以访问
cout << *p << endl;
//会出错
system("pause");
return 0;
}

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

#include<iostream>
using namespace std;
int main() {
//在程序中，尽量避免出现野指针
int* p = (int*)0x1100;
//0x1100是十六进制的数，前面加上（int*）变为指针类型，没有权限操作那块内存
cout << *p << endl;
//报错
system("pause");
return 0;
}

7.5 const修饰指针

#include<iostream>
using namespace std;
int main() {
//1、const修饰指针 常量指针
int a = 10;
int b = 20;
const int* p = &a;
//指针指向的值不可以改，指针的指向可以改
//*p = 20;错误
p = &b;
//正确
//2、const修饰常量
指针常量
//指针的指向不可以改，指针指向的值可以改
int* const p2 = &a;
*p2 = 100;//正确
//p2 = &b;//错误，指针的指向是不可以改的
//3、const修饰指针和常量
const int* const p3 = &a;
//指针的指向 和指向的值
都不可以改
//*p3 = 100;
//错误
//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++;
cout << "利用指针访问第二个元素：" << *p << endl;//让指针向后偏移4个字节
cout << "利用指针遍历数组" << endl;
int* p2 = arr;
for (int i = 0; i < 12; 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 << "swap01 b= " << b << endl;
}
void swap02(int *p1, int *p2)
{
int temp = *p1;
*p1 = *p2;
*p2 = temp;
//cout << "swap01 *p1= " << *p1 << endl;
//形参改变了
//cout << "swap01 *p2= " << *p2 << endl;
}
int main() {
//指针和函数
//1、值传递
int a = 10;
int b = 20;
//swap01(a, b);
//2、地址传递
//如果是地址传递，可以修改实参
swap02(&a, &b);
cout << "a= " << a << endl;
//实参未改变
cout << "b= " << b << endl;
system("pause");
return 0;
}

7.8 指针、数组、函数

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

#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 - 1 - i; 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[] = { 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 结构体

8.1结构体基本概念

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

8.2 结构体定义和使用

**语法：**struct 结构体名{结构体成员列表}；
通过结构体创建变量的三种表达方式：

• struct 结构体名 变量名 （常用）
• struct 结构体名 变量名 = {成员1值，成员2值。。} （常用）
• 定义结构体时顺便创建变量
  结构体创建时struct可以省略，但定义结构体时不可以
  结构体变量利用操作符“.”访问成员

#include<iostream>
using namespace std;
#include<string>
// 1、创建学生数据类型：学生包括（姓名，年龄，分数）
//自定义数据类型，一些类型集合组成的一个类型
//语法：struct 结构体名{结构体成员列表}；
struct Student
{
//成员列表
//姓名
string name;
//年龄
int age;
//分数
int score;
}s3;//顺便创建结构体变量
//2、通过学生类型创建具体学生
int main() {
//2.1 struct Student s1
//struct是可以省略（创建时可以省略，定义时不可以）
struct Student s1;
//给s1属性赋值，通过.访问结构体变量中的属性
s1.name = "张三";
s1.age = 19;
s1.score = 100;
cout << "姓名是：" << s1.name << "年龄是" << s1.age << "分数是：" << s1.score << endl;
//2.2 struct Student s2= {...}
struct Student s2 = { "张三",18,99 };
cout << "姓名是：" << s2.name << "年龄是" << s2.age << "分数是：" << s2.score << endl;
//2.3 在定义结构体时顺便创建结构体变量
s3.name = "张三";
s3.age = 19;
s3.score = 100;
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},
{"李四",19,101},
{"王五",20,102}
};
//3、给结构体数组中的元素赋值
StuArray[2].name = "李二";
StuArray[2].age = 21;
StuArray[2].score = 104;
//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;
//结构体定义
struct student
{
string name;
int age;
int score;
};
int main() {
//1、创建学生结构体变量
struct student s = { "张三",18 ,200 };
//2、通过指针指向结构体变量
student* p = &s;
//struct省略
//3、通过指针访问结构体变量中的数据
//通过结构体指针
访问结构体中的属性
需要利用‘ -> ’
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 = 100;
t. name = "老王";
t.age = 50;
t.stu.name = "小李";
t.stu.age = 19;
t.stu.score = 99;
cout << "
老师工号：" << t.id
<< "
老师姓名：" << t.name
<< "
老师年龄：" << t.age
<< "
学生姓名：" << t.stu.name
<< "
学生年龄：" << t.stu.age
<< "
学生分数: " << t.stu.score << endl;
system("pause");
return 0;
}

8.6 结构体做函数参数

**作用：**将结构体作为参数向函数中传递
两种方式：

• 值传递 （主函数中数据不修改）
• 地址传递 （修改主函数中的数据）

#include<iostream>
using namespace std;
//定义学生结构体
struct student
{
string name;
int age;
int score;
};
//打印学生信息函数
//1、值传递
void printStudent1(struct student s)
{
s.age = 100;
cout << "子函数 1 中
姓名：" << s.name << "
年龄：" << s.age << "
分数：" << s.score << endl;
}
//2、地址传递
void printStudent2(struct student * p)
{
p->age = 200;
cout << "子函数 2 中
姓名：" << p->name << "
年龄：" << p->age << "
分数：" << p->score << endl;
}
int main() {
struct student s;
s.name = "小王";
s.age = 18;
s.score = 400;
printStudent2(&s);
printStudent1(s);
cout << "main函数中
姓名：" << s.name << "
年龄：" << s.age << "
分数：" << s.score << endl;
system("pause");
return 0;
}

• 值传递 数组 是用 “.” 访问结构体成员
• 地址传递 （即指针） 是用“->”访问结构体成员

8.7 结构体中const使用场景

作用：用 const 防止误操作

#include<iostream>
using namespace std;
//定义学生结构体
struct student
{
string name;
int age;
int score;
};
//创建打印函数
//将函数中的形参改为指针，可以减少内存空间，而且不会复制新的副本出来
void printStudents(const student *s) //原来是值传递，但是占用内存空间，用指针的地址传递，但修改子函数中的参数，主函数也会发生改变，故加入const防止误操作
{
//s->age = 100;
//加入const之后，一旦有修改的操作就会报错，可以防止我们的误操作
cout<< "姓名：" << s->name << "
年龄：" << s->age << "
分数：" << s->score << endl;
}
int main() {
//创建结构体变量
struct student s = { "张三", 18 , 400 };
//通过函数打印结构体变量信息
printStudents(&s);
cout <<"
main中年龄：" << s.age << endl;
system("pause");
return 0;
}

8.8 结构体案例1

//案例1--3名老师带 5名学生做毕设
//学生--姓名、考试分数、
#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、创建3名老师数组
struct teacher tArray[3];
//2、通过函数给3名老师的信息赋值，并给老师带的学生信息赋值
int len = sizeof(tArray) / sizeof(tArray[0]);
allocateSpace(tArray, len);
//3、打印所有老师及所带的学生信息
printInfo(tArray, len);
system("pause");
return 0;
}

8.9 结构体案例2

#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++)
{
//如果j 下标元素年龄 大于 j+1 下标的元素的年龄 ，交换两个元素
if (heroArray[j].age > heroArray[j + 1].age)
{
struct Hero temp = heroArray[j];
heroArray[j] = heroArray[j + 1];
heroArray[j + 1] = temp;
}
}
}
}
//打印排序后数组中的信息
void printHero(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、创建数组存放5名英雄
struct Hero heroArray[5] =
{
{"刘备",23,"男"},
{"关羽",22,"男"},
{"张飞",20,"男"},
{"赵云",21,"男"},
{"貂蝉",19,"女"},
};
int len = sizeof(heroArray) / sizeof(heroArray[0]);
cout << "排序后打印：" << endl;
for (int i = 0; i < len; i++)
{
cout << "姓名：" << heroArray[i].name
<< " 年龄：" << heroArray[i].age
<< "性别：" << heroArray[i].sex << endl;
}
//3、对数组进行排序，按照年龄进行升序排序
bubbleSort(heroArray, len);
cout << "排序后打印：" << endl;
//4、将排序后结果打印输出
printHero(heroArray, len);
system("pause");
return 0;
}

9 通讯录管理系统

9.1 系统需求

实现功能如下：

• 1、添加联系人：向通讯录中添加新人，信息包括（姓名、性别、年龄、联系电话、家庭住址）最多纪录1000
• 2、显示联系人：显示通讯录中所有联系人的信息
• 3、删除联系人：按照姓名进行删除指定联系人
• 4、查找联系人：按照姓名查看指定联系人信息
• 5、修改联系人：按照姓名重新修改指定联系人
• 6、清空联系人：清空通讯录中所有信息
• 0、退出通讯录：退出当前使用的通讯录

9.2 创建项目

9.3 菜单功能

功能描述：用户选择功能的界面
实现步骤：

• 封装函数显示该界面 如 void showMenu（）
• 在main函数中调用封装好的函数

9.4 退出功能

功能描述：退出通讯录系统
思路：根据用户不同的选择，进入不同的功能，可以选择switch分支结构，将整个架构进行搭建
当用户选择0的时候，执行退出，选择其他先不做操作，也不会退出程序

9.5 添加联系人

功能描述：
实现添加联系人功能，联系人上限位1000人，联系人信息包括（姓名，性别，年龄，联系电话，家庭住址）
实现步骤：

• 设计联系人结构体
• 设计通讯录结构体
• main函数中创建通讯录
• 封装添加联系人函数
• 测试添加联系人功能

9.6 显示联系人

功能描述：
显示通讯录中已有联系人信息
显示联系人实现步骤：

• 封装显示联系人函数（思路：判断如果当前通讯录中没有人员，就提示记录为空，人数大于0，显示通讯录中的信息）
• 测试显示联系人函数

9.7 删除联系人

功能描述：按照姓名进行删除指定联系人
实现步骤：

• 封装检测联系人是否存在（设计思路：删除联系人前，我们需要先判断用户输入的联系人是否存在，如果删除，不存在提示用户没有要删除的联系人，一次我们可以把要检测联系人是否存在封装成一个函数中，如果存在，返回联系人在通讯录中的位置，不存在返回-1）
• 封装删除联系人函数
• 测试删除联系人功能

9.8 查找联系人

9.9 修改联系人

功能描述：按照姓名重新修改指定联系人
实现步骤

• 封装函数
• 测试功能
  实现思路：查找用户输入的联系人，如果查找成功进行修改操作，查找失败提示查无此人

9.10 清空联系人

#include<iostream>
using namespace std;
#include<string>
#define MAX 1000
//宏常量
//设计联系人结构体
struct Person
{
string m_Name;
int m_Sex;
int m_Age;
string m_Phone;
string m_Addr;
};
//设计通讯录结构体
struct Addressbooks
{
//通讯录中保存的联系人数组
struct Person personArray[MAX];
//嵌套
//通讯录中当前记录联系人个数
int m_Size;
};
//菜单界面
void showMenu()
{
cout << "****************************" << endl;
cout << "******
1、添加联系人
*****" << endl;
cout << "******
2、显示联系人
*****" << endl;
cout << "******
3、删除联系人
*****" << endl;
cout << "******
4、查找联系人
*****" << endl;
cout << "******
5、修改联系人
*****" << endl;
cout << "******
6、清空联系人
*****" << endl;
cout << "******
0、退出通讯录
*****" << endl;
cout << "****************************" << endl;
}
//1、添加联系人
void addPerson(Addressbooks* abs)
{
//判断通讯库是否已满，如果满了就不在添加
if (abs->m_Size == MAX)
{
cout << "通讯录已满，无法添加！" << endl;
return;
}
else
{
//添加联系人
string name;
cout << "请输入姓名:" << endl;
cin >> name;
abs->personArray[abs->m_Size].m_Name = name;
//性别
cout << "请输入性别：" << endl;
cout << "1---男" << endl;
cout << "2---女" << endl;
int sex = 0;
while (true)
{
//如果输入的是1 或者 2 可以退出循环，因为输入的是正确值
//如果输入有误，重新输入
cin >> sex;
if (sex == 1 || sex == 2)
{
abs->personArray[abs->m_Size].m_Sex = sex;
break;
}
cout << "输入有误，请重新输入" << endl;
}
//年龄
cout << "请输入年龄：" << endl;
int age = 0;
cin >> age;
abs->personArray[abs->m_Size].m_Age = age;
//电话
cout << "请输入联系电话：" << endl;
string phone;
cin >> phone;
abs->personArray[abs->m_Size].m_Phone = phone;
//地址
cout << "请输入家庭住址：" << endl;
string address;
cin >> address;
abs->personArray[abs->m_Size].m_Addr = address;
//更新通讯录人数
abs->m_Size++;
cout << "添加成功" << endl;
system("pause");
//按任意键继续
system("cls");
//清屏操作
}
}
//2、显示联系人
void showPerson(Addressbooks* abs)
{
//判断通讯录中人数是否为0，如果是0，提示记录为空
//如果不是0，显示记录的联系人信息
if (abs->m_Size == 0)
{
cout << "当前记录为空" << endl;
}
else
{
for (int i = 0; i < abs->m_Size; i++)
{
cout << "姓名： " << abs->personArray[i].m_Name << "t";
cout << "性别： " << (abs->personArray[i].m_Sex == 1 ? "男" : "女") << "t";
cout << "年龄： " << abs->personArray[i].m_Age << "t";
cout << "电话： " << abs->personArray[i].m_Phone << "t";
cout << "住址： " << abs->personArray[i].m_Addr << endl;
}
}
system("pause");
system("cls");
//清屏
}
//检测联系人是否存在， 如果存在，返回联系人所在数组中的具体位置，不存在返回-1
//参数1
通讯录
参数2
对比姓名
int isExist(Addressbooks* abs, string name)
{
for (int i = 0; i < abs->m_Size; i++)
{
//找到用户输入的姓名
if (abs->personArray[i].m_Name == name)
{
return i;
//找到啦，返回这个人在数组中的下标编号
}
}
return -1;//如果遍历结束没有找到，返回-1
}
//3、删除联系人

void deletePerson(Addressbooks* abs)
{
cout << "请输入您要删除的联系人" << endl;
string name;
cin >> name;
//ret == -1
未查到
//ret ！= -1
查到了
int ret = isExist(abs, name);
if (ret != -1)
{
//查找到人，要进行删除操作
for (int i = ret; i < abs->m_Size; i++)
{
//数据前移
abs->personArray[i] = abs->personArray[i + 1];
}
abs->m_Size--;
//更新通讯录中人员数
cout << "删除成功" << endl;
}
else
{
cout << "查无此人" << endl;
}
system("pause");
system("cls");
}
//4、查找联系人
void findPerson(Addressbooks* abs)
{
cout << "请输入您要查找的联系人" << endl;
string name;
cin >> name;
//判断指定的联系人是否在通讯录中
int ret = isExist(abs, name);
if (ret != -1)
{
cout << "姓名： " << abs->personArray[ret].m_Name << "t";
cout << "性别： " << (abs->personArray[ret].m_Sex == 1 ? "男" : "女") << "t";
cout << "年龄： " << abs->personArray[ret].m_Age << "t";
cout << "电话： " << abs->personArray[ret].m_Phone << "t";
cout << "住址： " << abs->personArray[ret].m_Addr << endl;
}
else
//未找到联系人
{
cout << "查无此人" << endl;
}
system("pause");
system("cls");
}
//5、修改联系人
void modifyPerson(Addressbooks* abs)
{
cout << "请输入您要修改的联系人" << endl;
string name;
cin >> name;
int ret = isExist(abs, name);
if (ret != -1)
//找到指定联系人
{
//姓名
string name;
cout << "请输入姓名:" << endl;
cin >> name;
abs->personArray[ret].m_Name = name;
//性别
cout << "请输入性别：" << endl;
cout << "1---男" << endl;
cout << "2---女" << endl;
int sex = 0;
while (true)
{
cin >> sex;
if (sex == 1 || sex == 2)
{
//输入正确
退出循环输入
abs->personArray[ret].m_Sex = sex;
break;
}
cout << "输入有误，请重新输入" << endl;
}
//年龄
cout << "请输入年龄：" << endl;
int age = 0;
cin >> age;
abs->personArray[ret].m_Age = age;
//电话
cout << "请输入联系电话：" << endl;
string phone;
cin >> phone;
abs->personArray[ret].m_Phone = phone;
//地址
cout << "请输入家庭住址：" << endl;
string address;
cin >> address;
abs->personArray[ret].m_Addr = address;
cout << "修改成功" << endl;
}
else
//为找到联系人
{
cout << "查无此人" << endl;
}
system("pause");
//按任意键继续
system("cls");
//清屏操作
}
//6、清空联系人
void cleanPerson(Addressbooks* abs)
{
abs->m_Size = 0;
//将当期记录联系人数量置为0，做逻辑清空操作
cout << "通讯录已清空" << endl;
system("pause");
system("cls");
}
int main() {
//创建通讯录结构体变量
Addressbooks abs;
//初始化通讯录中当前人员个数
abs.m_Size = 0;
int select = 0;
//创建用户选择输入的变量
while (true)
{
//菜单调用
showMenu();
cin >> select;
switch (select)
{
case 1:
//1、添加联系人
addPerson(&abs);
//利用地址传递，可以修饰实参
break;
case 2:
//2、显示联系人
showPerson(&abs);
break;
case 3:
//3、删除联系人
//一大段代码，加大括号变成代码段
/*{
cout << "请输入删除联系人姓名：" << endl;
string name;
cin >> name;
if (isExist(&abs, name) == -1)
{
cout << "查无此人" << endl;
}
else
{
cout << "找到此人" << endl;
}
}*/
deletePerson(&abs);
break;
case 4:
//4、查找联系人
findPerson(&abs);
break;
case 5:
//5、修改联系人
modifyPerson(&abs);
break;
case 6:
//6、清空联系人
cleanPerson(&abs);
break;
case 0:
//0、退出通讯录
cout << "欢迎下次使用" << endl;
system("pause");
return 0;
break;
default:
break;
}
}
system("pause");
return 0;
}

最后

以上就是火星上白昼为你收集整理的c++ 知识点 基础篇1 C++初识2 数据类型3 运算符4 程序流程结构5 数组6 函数7 指针8 结构体9 通讯录管理系统的全部内容，希望文章能够帮你解决c++ 知识点 基础篇1 C++初识2 数据类型3 运算符4 程序流程结构5 数组6 函数7 指针8 结构体9 通讯录管理系统所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。