c++ 知识点基础篇

最新推荐文章于 2024-05-05 11:35:29 发布

远古时代的完美囚徒

最新推荐文章于 2024-05-05 11:35:29 发布

阅读量259

点赞数 1

分类专栏： C++ 文章标签： c++

原文链接：https://www.bilibili.com/video/BV1et411b73Z

版权

C++ 专栏收录该内容

3 篇文章 0 订阅

订阅专栏

配套视频：
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 标识符命名规则

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

2 数据类型

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

2.1 整型

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

数据类型	占用空间	取值范围
short(短整型）	2字节	（(-2^15 ~ 2^15-1)）
int(整型）	4字节	（-2^31 ~ 2^31-1）
long(长整型）	Windows为4字节，Linux为4字节（32位），8字节（64位）	（-2^31 ~ 2^31-1）
long long(长长整型）	8字节	（-2^63 ~ 2^63-1）

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 转义字符

转义字符	含义	ASCII（十进制）
\a	警报	007
\n	换行	010
\t	水平制表	009
\	\	092

#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 加减乘除

运算符	术语	实例	结果
+	正号或加号	+3
-	负号或减号	-3
*	乘
/	除	10/3	3
%	取模（取余）	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 << 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 逻辑运算符

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

运算符	术语	示例	结果
！	非	！a	假为真，真为假
&&	与	a&&b	全真为真，一假则假
			或

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;
}

远古时代的完美囚徒

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
1
评论
c++ 知识点基础篇

1 C++初识1.4 常量//常量：用于记录程序中不可更改的数据//1、#define 宏常量：#define 常量名常量值//通常定义在文件上方，表示一个常量//2、const修饰的变量：const 数据类型常量名 = 常量值//通常在变量定义前加关键字const，修饰改变量为常量，不可修改#include<iostream>using namespace std;//1、#define 宏常量：#define Day 7int main() { //Day
复制链接

扫一扫