C++基础入门学习笔记

方的言

已于 2022-03-19 09:48:48 修改

阅读量521

点赞数

分类专栏： C++学习笔记文章标签： c++ 学习

于 2022-03-15 15:19:15 首次发布

本文链接：https://blog.csdn.net/zwyzhy/article/details/123503033

版权

C++学习笔记专栏收录该内容

5 篇文章 1 订阅

订阅专栏

C++ 基础入门学习笔记

1 C++ 初识

1.1 变量

意义：便于管理内存空间

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

示例：

int main(){
	// 创建变量：数据类型 变量名 = 变量初始值；
	int a = 10;
	cout << "a=" << a << endl;

	system("pause");
	return 0;
}

1.2 常量

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

两种定义方式：

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

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

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

通常在变量名前加关键字const，修饰变量为常量，不可修改

示例：

//1、#define 宏常量
#define Day 7

int main(){  
	//Day = 10; //错误，此处Day是常量不可修改
	cout << "一周有=" << Day<<"天" << endl;
    
	// 2、const修饰的变量
	const int month = 12;
	//month = 25; //错误，const修饰的变量也是常量
	cout << "一年有=" << month << "月份" << endl;
    
	system("pause");
	return 0;
}

1.3 标识符（变量、常量）命名规则

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

变量起名时，尽量见字知意

2 数据类型

C++创建变量或常量时，必须指定数据类型，否则无法分配内存空间

2.1 整型

作用：整型变量表示的是整数类型数据，不同类型区别：所占空间不同

数据类型	占用空间
int（整型）最常用	4字节
short（短整型）	2字节
long（长整型）	Windows为4字节，Linux为4字节（32位），8字节（64位）
long long（长长整型）	8字节

示例：

int main() {
	// 01整型

	//1、短整型 (-3278~32767)
	short num1 = 3278;	//超出数据范围会出错
	//2、整型
	int num2 = 10;
	//3、长整型
	long num3 = 10;
	//4、长长整型
	long long num4 = 10;

	cout << "num1=" << num1 << endl;
	cout << "num2=" << num2 << endl; 
	cout << "num3=" << num3 << endl;
	cout << "num4=" << num4 << endl;

	system("pause");
	return 0;
}

2.2 sizeof关键字

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

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

示例：

int main() {
	//02、sizeof关键字

	//可以用sizeof求出数据类型所占内存大小
	//语法：sizeof（数据类型/变量名）

	short num1 = 10;
	cout << "short所占内存空间为：" << sizeof(num1) << endl;
	int num2 = 10;
	cout << "int所占内存空间为：" << sizeof(num2) << endl;

	//整型大小比较
	// short < int <=long <=long long

	system("pause");
	return 0;
}

2.3 实型（浮点型）

作用：表示小数

浮点型分为两种：

1.单精度：float

2.双精度：double

数据类型	占用空间	有效数字范围
float	4字节	7位有效数字
double	8字节	15~16位有效数字

示例：

int main() {
	//实型（浮点型）
	//单精度：float
	//双精度：double
	//默认情况下 输出一个小数，会显示6位有效数字
	float f1 = 3.1415926f; //加f是为了确定是单精度，否则系统默认为双精度（double）
	cout << "f1=" << f1 << endl;
	double d1 = 3.14159266;
	cout << "d1=" << d1 << endl;
	//统计float和double占用内存空间
	cout << "float占用内存空间位：" << sizeof(float) << endl;
	cout << "double占用内存空间位：" << sizeof(double) << endl;

	//科学计数法
	float f2 = 3e2;	// 3 * 10 ^ 2
	cout << "f2=" << f2 << endl;
	float f3 = 3e-2;// 3 * 0.1 ^ 2
	cout << "f3=" << f3 << endl;

	system("pause");
	return 0;
}

2.4 字符型

作用：字符型变量用于显示单个字符

语法：char ch = 'a'；

C++中字符型变量只占用1个字节
字符型变量并非是把字符本身放到内存中，而是将对应的ASCII编码放到存储单元

示例：

int main() {

	//字符型
	//1、字符型变量创建方式
	char ch = 'a';
	cout << ch << endl;

	//2、字符型变量所占你内存大小
	cout << "char字符型变量所占内存为：" << sizeof(char) << endl;

	//3、字符型变量常见错误
	//char ch2 = "b";	//创建字符型变量时，只能用单引号
	//char ch3 = 'cdefg';	//创建字符型变量时，单引号内只能引用一个字符

	//4、字符型变量对应ASCII编码 
	// a-97
	//A-65
	cout << (int)ch << endl;

	system("pause");
	return 0;
}

ASCII编码大致分为两部分：

ASCII非打印控制符：ASCII表上数字0~31分配给控制字符，用于控制一些外围设备
ASCII打印字符：数字32~126分配给键盘上能找到的字符

2.5 转义字符

作用：用于表示一些不能显示的ASCII字符

现阶段常用转义字符：\n \t \\

示例：

int main() {

	//转义字符
	//换行符 \n
	cout << "hello world\n" << endl;
	
    // 反斜杠 \\
	cout << "\\" << endl;

	// 水平制表符	作用：可以整齐输出数据
	cout << "aaaa\thello world\t" << endl;
	cout << "aa\thello world\t" << endl;
	cout << "aaaaaa\thello world\t" << endl;

	system("pause");
	return 0;
}

2.6 字符串类型

作用：表示一串字符

两种风格：

C风格字符串：char 变量名[] = "字符串值"
C++风格字符串：string 变量名 = "字符串值"

示例：

int main() {

	//字符串类型
	//1、C风格字符串
	//注意事项1：字符串名后要加[]，否则即是创建一个字符
	//注意事项2：等号后要用双引号包含字符串
	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类型只占用一个字节

示例：

int main() {

	//1、创建bool数据类型
	bool flag = true;//true代表真
	cout << flag << endl;

	flag = false;//false代表假
	cout << flag << endl;

	//2、查看bool数据类型内存空间
	cout << "bool数据类型所占空间位：" << sizeof(bool) << endl;

	system("pause");
	return 0;
}

2.8 数据的输入

作用：从键盘上获取数据

关键字：cin

语法：cin >> 变量

示例：

int main() {

	//1、整型
	int a = 0;
	cout << "请给整型变量a赋值" << endl;
	cin >> a;
	cout << "整型变量a=" << a << endl;

	//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 = "hello";
	cout << "请给字符串型变量str赋值" << endl;
	cin >> str;
	cout << "字符串型变量str=" << str << endl;
	
	//5、布尔类型	非零值都代表1（真）
	bool flag = true;
	cout << "请给布尔类型变量flag赋值" << endl;
	cin >> flag;
	cout << "布尔类型变量flag=" << flag << endl;

	system("pause");
	return 0;
}

3 运算符

作用：执行代码运算

运算法类型	作用
算术运算符	处理四则运算
赋值运算符	将表达式的值赋给变量
比较运算符	用于表达式的比较，并返回一个真值或假值
逻辑运算符	根据表达式的值返回真值或假值

3.1 算术运算符

示例1：加减乘除运算

int main() {
	//加减乘除运算
	int a1 = 10;
	int b1 = 20;

	cout << a1 + b1 << endl;
	cout << a1 - b1 << endl;
	cout << a1 * b1 << endl;
	cout << a1 / b1 << endl;//两个整数相除，结果仍是整数，将小数部分去除

	int a2 = 10;
	int b2 = 0;
	//cout << a2 / b2 << endl;//错误，两个整数相除，除数不能为0

	//两个小数可以相除
	double a3 = 0.05;
	double b3 = 0.1;
	cout << a3 / b3 << endl;

	system("pause");
	return 0;
}

运算符	术语	示例	结果
%	取模（取余）	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

示例2：取模运算

int main() {

	//取模运算本质就是求余数
	int a4 = 10;
	int b4 = 3;
	cout << a4 % b4 << endl;

	int a5 = 10;
	int b5 = 20;
	cout << a5 % b5 << endl;//取模运算除不过时，结果为本身

	int a6 = 10;
	int b6 = 0;
	//cout << a6 % b6 << endl;//两个数相除除数不可为0，也不能取模

	//两个小数不可以做取模运算
	double d1 = 0.5;
	double d2 = 0.2;
	//cout << d1 % d2 << endl;//错误

	system("pause");
	return 0;
}

示例3：递增和递减

int main() {

	//递增和递减
	//1、前置递增
	int a = 10;
	++a;
	cout << "a=" << a << endl;
	//2、后置递增
	int b = 10;
	b++;
	cout << "b=" << b << endl;
	//3、前置与后置区别
	//前置递增：先让变量++，再进行表达式运算
	int a7 = 10;
	int b7 = ++a7 * 10;
	cout << "a7=" << a7 << endl;// a7=11
	cout << "b7=" << b7 << endl;// b7=110

	//后置递增：先让进行表达式运算，再让变量++
	int a8 = 10;
	int b8 = a8++ * 10;
	cout << "a8=" << a8 << endl;// a8=11
	cout << "b8=" << b8 << endl;// b8=100

	system("pause");
	return 0;
}

3.2 赋值运算

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

运算符	术语	示例	结果
=	赋值	a=2;b=3	a=2;b=3
+=	加等于	a=0,a+=2	a=2
-=	减等于	a=5;a-=3	a=2
*=	乘等于	a=2;a*=2	a=4
/=	除等于	a=4;a/=2	a=2
%=	模等于	a=3;a%=2	a=1

示例：

int main() {
	//赋值运算符
	// =
	int a = 10;
	a = 100;
	cout << "a =" << a << endl;

	// +=
	a = 10;
	a += 2;// a = a + 2
	cout << "a =" << a << endl;// a = 12

	// -=
	a = 10;
	a -= 2;// a = a - 2
	cout << "a =" << a << endl;// a = 8

	// *=
	a = 10;
	a *= 2;// a = a * 2
	cout << "a =" << a << endl;// a = 20

	// /=
	a = 10;
	a /= 2;// a = a / 2
	cout << "a =" << a << endl;// a = 5

	// %=
	a = 10;
	a %= 2;// a = a % 2
	cout << "a =" << a << endl;// a = 0

	system("pause");
	return 0;
}

3.3 比较运算符

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

示例：

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为真，则!a为假
&&	与	a && b	若a和b都为真，则结果为真；反之结果为假
\|\|	或	a \|\| b	若a和b有一个为真，则结果为真；二者都为假时，结果为假

示例：

int main() {
	// 逻辑运算符 非 !
	int a = 10;
	// 在C++中，除0外都为真
	cout << !a << endl;// 0
	cout << !!a << endl;// 1

	// 逻辑运算符 与 &&
	int a1 = 10;
	int b1 = 10;
	cout << (a1 && b1 ) << endl;// 1

	a1 = 10;
	b1 = 0;
	cout << (a1 && b1) << endl;// 0

	// 逻辑运算符 或 ||
	int a2 = 10;
	int b2 = 0;
	cout << (a2 || b2) << endl;// 1

	int a3 = 0;
	int b3 = 10;
	cout << (a3 || b3) << endl;// 1

	int a4 = 0;
	int b4 = 0;
	cout << (a4 || b4) << endl;// 0

	system("pause");
	return 0;
}

4 程序流程结构

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

顺序结构：程序按顺序进行，不发生跳
选择结构：依据条件是否满足，有选择的执行相应功能
循环结构：依据条件是否满足，循环多次执行代码

4.1 选择结构

4.1.1 if语句

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

if语句的三种形式：

单行格式if语句
多行格式if语句
多条件的if语句

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

示例：

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语句：if（条件）{条件满足执行语句}else{条件不满足执行语句}

示例：

int main() {
	// 选择结构 多行if语句
	// 输入考试分数，如果考试分数大于600视为考上一本大学，在屏幕上输出；
    //如果未考上一本大学，未考上一本大学

	//1、输入考试分数
	int score = 0;
	cout << "请输入您的分数:" << endl;
	cin >> score;

	//2、提示用户输入分数
	cout << "您输入的分数为：" << score << endl;

	//3、判断，如果大于600，打印考上一本，否则打印未考上一本
	if (score > 600)	//大于600分执行下面括号里的内容
	{
		cout << "恭喜您考上一本大学" << endl;
	}
	else	//不大于600分，执行else后大括号中的语句
	{
		cout << "很遗憾，您没有考上一本大学" << endl;
	}

	system("pause");
	return 0;
}

多条件的if语句：if（条件1）{条件1满足执行语句}else if（条件2）{条件2不满足执行语句}...else{都不满足执行的语句}

示例：

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语句，以达到更精准的判断

案例分析：

提示用户输入考试分数，根据考试分数做如下判断
如果分数大于600分，视为考上一本大学；分数大于500分，视为考上二本大学；分数大于400分，视为考上三本大学；分数小于400分，视为未考上本科
在一本分数中，如果分数大于700分，视为考上清华；分数大于650分，视为考上北大；分数大于600分，视为考上人大

源代码：

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

**练习案例：**三只小猪称体重

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

源代码：

int main() {
	//三只小猪称体重，判断哪只最重

	//1、创建三只小猪的体重变量
	int num1 = 0;
	int num2 = 0;
	int num3 = 0;

	//2、让用户输入三只小猪的重量
	cout << "请输入小猪A的体重" << endl;
	cin >> num1;

	cout << "请输入小猪B的体重" << endl;
	cin >> num2;

	cout << "请输入小猪C的体重" << endl;
	cin >> num3;

	cout << "小猪A的体重为：" << num1 << endl;
	cout << "小猪B的体重为：" << num2 << endl;
	cout << "小猪C的体重为：" << num3 << endl;

	//3、判断哪只最重
	if (num1 > num2) 
	{
		if (num1 > num3)
		{
			cout << "小猪A最重，小猪A的体重为：" << num1 << endl;
		}
		else
		{
			cout << "小猪C最重，小猪C的体重为：" << num3 << endl;
		}
	}
	else
	{
		if (num2 > num3)
		{
			cout << "小猪B最重，小猪B的体重为：" << num2 << endl;
		}
		else
		{
			cout << "小猪C最重，小猪C的体重为：" << num3 << endl;
		}
	}
    
	system("pause");
	return 0;
}

4.1.2 三目运算符

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

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

解释：

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

示例：

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

C++ 中三目运算符返回的是变量，可以继续赋值

4.1.3 Switch语句

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

语法：

switch (表达式)
{
	case 结果1：执行语句； break；
        
	case 结果2：执行语句； break；
        
	...
        
	default:执行语句；break；
	
}

示例：

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

	system("pause");
	return 0;
}

注意1：Switch语句中表达式只能是整型或字符型

注意2：case里如果没有break，那么程序会一直向下执行

if 和 Switch 语句的区别？

Switch 缺点：判断时候只能是整型或者字符型，不可以是一个区间
Switch 有点：结构清晰，执行效率高

4.2 循环结构

4.2.1 while循环语句

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

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

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

int main() {
	//while循环
	//在循环中打印 0 ~ 9 这10个数字
	int num = 0;

	//while（）中填入循环条件
	//注意事项：在写循环时一定要避免进入死循环
	while (num < 10)
	{
		cout << num << endl;
		num++;
	}

	system("pause");
	return 0;
}

while循环练习案例：猜数字

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

源代码：

int main() {
	//添加随机数种子 利用当前系统时间生成随机数，防止每次随机数一样
	srand((unsigned int)time(NULL));
	
	//1、系统生成随机数		rand---伪随机
	int num = rand() % 100 + 1;	//rand()%100+1 生成一个 0+1 ~ 99+1 的随机数		
	//cout << num << endl;

	//2、玩家进行猜测
	int val = 0;

	//3、判断玩家猜测
	
	//猜对		退出游戏
	//猜错		提示猜测的结果	过大或过小	重新返回第2步

	while (true)
	{
		cin >> val;
		if (val>num)
		{
			cout << "猜测过大" << endl;
		}
		else if (val<num)
		{
			cout << "猜测过小" << endl;
		}
		else
		{
			cout << "恭喜您猜对了" << endl;
			break;	//break，可以利用该关键字来退出当前程序
		}
	}

	system("pause");
	return 0;
}

4.2.2 do…while循环语句

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

语法：do{循环语句}while{循环条件}

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

示例：

int main() {
	//do...while循环语句
	//在屏幕中输出 0 ~ 9 这10个数字
	
	int num = 0;
	
	do
	{
		cout << num << endl;
		num++;
	} while (num<10);

	//do...while和while循环的区别在于do...while会先执行一次循环语句

	system("pause");
	return 0;
}

**练习案例：**水仙花数

**案例描述：**水仙花数是指一个3位数，它的每个位上的数字的3次幂之和等于它本身。

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

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

源代码：

int main() {
	//1、先打印所有的三位数字
	int num = 100;
	do
	{
		//2、从所有三位数中获取水仙花数
		int a = 0;//个位
		int b = 0;//十位
		int c = 0;//百位

		a = num % 10;//获取个位，eg：153 % 10 = 3
		b = num / 10 % 10;//获取十位，eg：153 / 10 = 15（C++中整数除法不显示小数）15 % 10 = 5
		c = num / 100;//获取百位，eg：153 / 100 = 1

		if (a*a*a + b*b*b + c*c*c == num)
		{
			cout << num << endl;
		}
		num++;
	} while (num<1000);

	system("pause");
	return 0;
}

4.2.3 for循环语句

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

语法：for（起始表达式；条件表达式；末尾循环体）{ 循环语句；}

示例：

int main() {
	//for循环
	//从0 打印到 9
	
	for (int i = 0; i < 10; i++)//起始表达式只执行1次；
	{
		cout << i << endl;
	}

	system("pause");
	return 0;
}

**练习案例：**敲桌子

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

源代码：

int main() {
	//敲桌子案例
	//1、先输出1~100数字
	for (int i = 1; i < 101; i++)
	{
		//2、从100个数字中找到特殊数字，打印“敲桌子”
		//如果是7的倍数，个位数是7，百位数是7，打印敲桌子
		if (i % 7 == 0 || i % 10 == 7 || i / 10 == 7)	//如果是特殊数字，打印敲桌子
		{
			cout << "敲桌子" << endl;
		}
		else	//如果不是特殊数字，才打印数字
		{
			cout << i << endl;
		}

	system("pause");
	return 0;
}

4.2.4 嵌套循环

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

示例：

int main() {
	//利用嵌套循环打印星图
	//打印一行星图

	//外层执行一次，内层执行一周
	//外层循环
	for (int n = 0; n < 10; n++)
	{
		//内层循环
		for (int i = 0; i < 10; i++)
		{
			cout << "* ";
		}
		cout << endl;
	}

	system("pause");
	return 0;
}

**练习案例：**乘法口诀表

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

源代码：

int main() {
	//乘法口诀表		列数 * 行数
	//打印行数
	for (int i = 1; i <= 9; i++)
	{
		//cout << i << endl;
		for (int j = 1; j <= i; j++)	//打印的列数要 <= 行数
		{
			cout << j <<"*"<<i<<"="<<j*i<<"\t";
		}
		cout << endl;
	}

	system("pause");
	return 0;
}

4.3 跳转语句

4.3.1 break语句

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

break使用的时机：

出现Switch条件语句中，作用是终止case并跳出Switch语句
出现在循环语句中，作用是跳出当前的循环语句
出现在嵌套语句中，跳出最近的内层循环语句

示例：

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;
	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 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语句

作用：在循环语句中，跳过本次循环中余下未执行语句，进入下一次循环

示例：

int main() {
	//continue语句

	for (int i = 0; i <= 100; i++)
	{
		//如果是奇数输出，偶数不输出
		if (i % 2 == 0)
		{
			continue;//可以筛选条件，执行到此就不会再向下执行，执行下一次循环
			//break会退出循环，而continue不会
		}
		cout << i << endl;
	}

	system("pause");
	return 0;
}

4.3.3 goto语句

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

语法：goto 标记；

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

示例：

int main() {
	//goto语句

	cout << "1、xxxxxxx" << endl;

	cout << "2、xxxxxxx" << endl;

	goto FLAG;

	cout << "3、xxxxxxx" << endl;

	cout << "4、xxxxxxx" << endl;

	FLAG://注意此处是 ':'

	cout << "5、xxxxxxx" << endl;

	system("pause");
	return 0;
}

学习此语句是为了了解能看懂，不建议使用。

5 数组

5.1 概述

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

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

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

5.2 一维数组

5.2.1 一维数组定义方式

一维数组定义的三种方式：

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

示例：

int main() {
	//数组

	1、数据类型 数组名[数组长度]；
	int arr[5];
	//给数组中元素赋值
	//数组下标的元素是从0开始的
	arr[0] = 10;
	arr[1] = 20;
	arr[2] = 30;
	arr[3] = 40;
	arr[4] = 50;

	//访问元素数据
	cout << arr[0] << endl;
	cout << arr[1] << endl;
	cout << arr[2] << endl;
	cout << arr[3] << endl;
	cout << arr[4] << endl;

	//2、数据类型 数组名[数组长度] = { 值1，值2 ... }；
	//如果初始化数据时，没有填写完数据，会用0填补
	int arr2[5] = { 10,20,30,40,50 };

	//利用循环输出数组中的元素
	for ( int i = 0; i < 5; i++ )
	{
		cout << arr2[i] << endl;
	}

	//3、数据类型 数组名[] = { 值1，值2 ... }；
	// 定义数组时，必须有初始长度
	int arr3[] = { 90,80,70,60,50,40,30,20,10 };

	for ( int i = 0; i < 9; i++ )
	{
		cout << arr3[i] << endl;
	}

	system("pause");
	return 0;
}

5.2.2 一维数组数组名

一维数组数组名用途：

可以统计整个数组在内存中的长度
可以获取数组在内存中的首地址

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;
	cout << "数组中第一个元素的地址为：" << (int)&arr[0] << endl;//&取址符
	cout << "数组中第二个元素的地址为：" << (int)&arr[1] << endl;

	//数组名是一个常量，不可以进行赋值
	//arr = 100；
    
	system("pause");
	return 0;
}

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

案例描述：

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

找出并打印最重的小猪体重。

源代码：

int main() {
	//1、创建五只小猪的数组
	int arr[5] = { 200,350,200,400,250 };

	//2、从数组中找出最大值
	int max = 0;//先认定一个最大值为0
	for(int i = 0; i < 6; i++)
	{
		if( arr[i]>max )
		{
			max = arr[i];//利用一个算法：遍历每个数组元素去比较赋值
		}
	}
	//3、打印最大值
	cout << "最大的小猪体重为：" << max << endl;

	system("pause");
	return 0;
}

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

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

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

源代码：

int main() {
	//实现数组元素逆置

	//1、创建数组
	int arr[5] = {1,2,3,4,5};
	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，直到不需要比较。

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 二维数组

5.3.1 二维数组定义方式

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

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

建议：以上四种定义方式，利用第二种更加直观，更具有可读性。

示例：

int main() {
	//二维数组定义方式
		//1. 数据类型 数组名[行数][列数]；
		//2. 数据类型 数组名[行数][列数] = { { 数据1，数据2 }， { 数据3，数据4 } }；
		//3. 数据类型 数组名[行数][列数] = { 数据1，数据2，数据3，数据4 }；
		//4. 数据类型 数组名[][列数] = { 数据1，数据2，数据3，数据4 }；
	//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;
	//外层循环打印行数，内层循环打印列数
	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;
}

5.3.2 二维数组数组名

查看数组所占内存空间
获取二维数组首地址

示例：

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) / sizeof(arr[0]) << endl;
	cout << "二维数组列数为：" << sizeof(arr[0]) / sizeof(arr[0][0]) << endl;

	//2、可以查看二维数组首地址
	cout << "二维数组首地址为：" << (int)arr << endl;
	cout << "二维数组第二行首地址为：" << (int)arr[1] << endl;
	cout << "二维数组第一行第一个元素首地址为：" << (int)&arr[0][0] << endl;
	cout << "二维数组第一行第二个元素首地址为：" << (int)&arr[0][1] << endl;

	system("pause");
	return 0;
}

5.2.3 二维数组应用案例

考试成绩统计：

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

	语文	数学	英语
张三	100	100	100
李四	90	50	100
王五	60	70	80

源代码：

int main() {
	//案例：考试成绩统计

	//1、创建二维数组
	int scores[3][3] =
	{
		{ 100,100,100 },
		{ 90,50,100 },
		{ 60,70,80 }
	};

	string name[3] = { "张三","李四","王五" };
		//2、统计每个人的总和输出
	for(int i = 0; i < 3; i++)
	{
		int sum = 0;//统计分数总和变量
		for(int j = 0; j < 3; j++)
		{
			sum += scores[i][j];
			//cout << scores[i][j] << " ";
		}
		cout << name[i]<<"的总分为：" << sum << endl;
	}

	system("pause");
	return 0;
}

6 函数

6.1 概述

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

6.2 函数的定义

函数的定义一般主要有5个步骤：

返回值类型
函数名
参数列表
函数体语句
return表达式

语法：

返回值类型 函数名 （参数列表）
{
	函数体语句

	return表达式

}

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

示例：两个数相加的加法函数

int add(int num1, int num2)
{
    int sum = num1 + num2;
    return sum;
}

6.3 函数的调用

//定义加法函数
//函数定义时，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;

	system("pause");
	return 0;
}

6.4 值传递

所谓的值传递，就是函数调用时，实参的值传递给形参
值传递时，如果形参反生，并不会影响实参

//值传递
//定义函数：实现两个数的交换
//如果一个函数不需要返回值，声明的时候可以写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;
}
int main()
{
	int a = 10;
	int b = 20;

	cout << "a = " << a << endl;
	cout << "b = " << b << endl;

	//当做值传递时，函数的形参发生任何的改变，不会影响实参
	swap(a,b);

	cout << "a = " << a << endl;
	cout << "b = " << b << endl;

	system("pause");
	return 0;
}

总结：值传递时，形参的任何改变都不影响实参

6.5 函数的常见样式

常见的函数样式有4种：

无参无返
有参无返
无参有返
有参有返

示例：

//函数的常见样式：
//1、无参无返
void test01 ()
{
	cout << "This is test01" << endl;
}
//2、有参无返
void test02 (int a)
{
	cout << "This is test02 a = " << a << endl;
}
//3、无参有返
int test03 ()
{
	cout << "This is test03 " << 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 (1000);
	cout << "num2 = " << num2 << endl;
    
    system("pause");
	return 0;
}

6.6 函数的声明

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

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

示例：

//函数的声明
//比较函数：比较两个数的大小，返回值较大的一个

//提前告诉编译器函数的存在，可以利用函数的声明；
//函数的声明：（当函数在后时，必须要写）
int max (int a, int b);

//定义
int max (int a, int b)
{
	return a > b ? a : b;
}
int main()
{
    int a = 10;
	int b = 20;
	cout << max (a, b) << endl;
    
    system("pause");
	return 0;
}

6.7 函数的分文件编写

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

函数分文件编写一般分为4个步骤：

创建后缀名为.h的头文件
创建后缀名为.cpp的源文件
在头文件中写函数的声明
在源文件中写函数的定义

示例：

//swap.h文件
#include<iostream>
using namespace std;

//函数的声明
void swap (int a, int b);

//swap.cpp文件
#include"swap.h"
//函数的定义
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;

}

//主程序main
#include<iostream>
using namespace std;
#include"swap.h"

//函数的分文件编写
//实现两个函数交换的函数
// 
//1. 创建后缀名为.h的头文件
//2. 创建后缀名为.cpp的源文件
//3. 在头文件中写函数的声明
//4. 在源文件中写函数的定义

int main ()
{
	int a = 10;
	int b = 20;
	swap(a,b);
	cout << "a = " << a << endl;
	cout << "b = " << b << endl;

	system ("pause");
	return 0;
}

7 指针

7.1 指针的基本概念

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

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

7.2 指针变量的定义和使用

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

示例：

int main ()
{
	//1、定义一个指针
	int	a = 10;
	//指针定义的语法：数据类型 * 变量名
	int * p;

	//让指针记录变量的地址
	p = &a;//指针指向a的地址
	cout << "a的地址为：" << &a << endl;//打印数据a的地址
	cout << "指针p为：" << p << endl;//打印指针变量p

	//2、使用指针
	//可以通过解引用的方式来找到指针指向的内存
	//指针前加 * 代表解引用，找到指针指向的内存中的数据
	*p = 1000;
	cout << "a=" << a <<endl;
	cout << "*p=：" << *p <<endl;

	system ("pause");
	return 0;
}

7.3 指针所占内存空间

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

示例：

int main ()
{
	//指针所占内存空间：
	int a = 10;
	//int * p;
	//p = &a;

	int * p = &a;
	//32操作系统下，指针占用4个字节内存空间
	//64操作系统下，指针占用8个字节内存空间
	cout << "sizeof (int * ) = " << sizeof (int *) << endl;
	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的空间

用途：初始化指针变量

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

示例1：空指针

int main ()
{
	//空指针
	//1、空指针用于给指针变量初始化
	int * p = NULL;

	//2、空指针是不可以访问的
	//0 ~ 255之间的内存编号是系统占用，因此不可以访问
	//*p = 100;

	system ("pause");
	return 0;
}

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

示例2：野指针

int main ()
{
	//野指针
	//在程序中，尽量避免出现野指针
	int * p = (int *)0x1100;

	cout << *p << endl;

	system ("pause");
	return 0;
}

总结：空指针和野指针都不是我们申请的内存空间，不可以访问

7.5 const修饰的指针

const修饰指针的三种情况：

const修饰指针：–常量指针
const修饰常量：–指针常量
const既修饰指针，又修饰变量

示例：

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 = &b;//错误
	*p2 = 20;

	//3、const既修饰指针，又修饰变量
	const int * const p3 = &a;

	//特点：指针的指向和指针指向的值都不可以改

	//*p3 = 20;//错误
	//p3 = &b;//错误

	system ("pause");
	return 0;
}

技巧：看const后面修饰的是指针还是变量，是常量就是指针常量；是指针就是常量指针

7.6 指针和数组

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

示例：

int main ()
{
	//指针和数组
	//利用指针访问数组中的元素

	int arr[ 10 ] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };

	int * p = arr;//指向数组的指针

	cout << "第一个元素为：" << arr[ 0 ] << endl;
	cout << "利用指针访问第一个元素：" << *p << endl;

	//p++;
	//cout << "利用指针访问第二个元素：" << *p << endl;

	for( int i = 0; i < 10; i++ )
	{
		//利用指针遍历数组
		cout << *p << endl;
		p++;//
	}

	system ("pause");
	return 0;
}

7.7 指针和函数

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

示例：

//实现两个数交换的函数
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;
}

int main ()
{
	//1、值传递
	int a = 10;
	int b = 20;
	//swap01 (a, b);//值传递不会改变实参

	//cout << "a = " << a << endl;
	//cout << "b = " << b << endl;

	//2、地址传递
	swap02 (&a, &b);//地址传递会改变实参的值

	cout << "a = " << a << endl;
	cout << "b = " << b << endl;

	system ("pause");
	return 0;
}

总结：如果不想修改实参，就要值传递；如果想修改实参，就用地址传递

7.8 指针、数组、函数

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

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

示例：

//冒泡函数	参数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++ )
		{
			if(arr[j]>arr[j+1] )
			{ 
				int temp = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = temp;
			}
		}
	}
}
//	int * p = arr;//指向数组的指针
//	cout << "第一个元素为：" << arr[ 0 ] << endl;
//	cout << "利用指针访问第一个元素：" << *p << endl;

//打印数组	传入数组的长度可以使函数更加灵活
void printArr (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、打印排序后的数组
	printArr (arr,len);

	system ("pause");
	return 0;
}

8 结构体

8.1 结构体基本概念

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

8.2 结构体定义和使用

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

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

struct 结构体名变量名
struct 结构体名变量名 = { 成员1值，成员2值 …}
定义结构体时顺便定义变量

示例：

//1、创建学生数据类型；	数据类型包括：姓名，年龄，分数
//自定义数据类型：一些内置数据类型的集合
//语法：struct 结构体名称 { 成员列表 }
struct student
{
	//成员列表

	//姓名
	string name;
	//年龄
	int age;
	//分数
	int score;

}s3;//顺便创建结构体变量; 

int main ()
{
	//2、通过学生数据类型创建具体的学生

	//2.1 struct student s1;
	//创建结构体变量时，struct关键字可以省略，但创建结构体定义时不可以省略
	student 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{"李四",20,90 };
	cout << "姓名： " << s2.name << " 年龄： " << s2.age << " 分数： " << s2.score << endl;

	//2.3 在定义结构体时顺便创建结构体变量
	s3.name = "王五";
	s3.age = 21;
	s3.score = 80;
	cout << "姓名： " << s3.name << " 年龄： " << s3.age << " 分数： " << s3.score << endl;

	system ("pause");
	return 0;
}

总结1：定义结构体时，struct关键字不可省略

总结2：创建变量时，struct关键字可省略

总结3：结构体变量利用 ‘.’ 操作符访问成员

8.3 结构体数组

**作用：**将自定义的结构体放入数组中方便维护

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

示例：

//结构体数组
//1、定义结构体
struct Student
{
	string name;//姓名
	int age;//年龄
	int score;//分数
};


int main ()
{
	//2、创建结构体数组
	struct Student stuArray[3] =
	{ 
		{ "张三",20,10 },
		{ "李四",21,90 },
		{ "王五",22,80 }
	};

	//3、给结构体数组中元素赋值
	stuArray[2].name = "狂徒";
	stuArray[2].age = 30;
	stuArray[2].score = 85;

	//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 结构体指针

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

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

示例：

//结构体指针

//定义结构体
struct student
{
	string name;//姓名
	int age;//年龄
	int score;//分数
};
int main()
{
	//1、创建结构体变量
	student s = { "张三",20,90 };

	//2、通过指针指向结构体变量
	student * p = &s;

	//3、通过指针访问结构体变量中的数据
	//通过结构体指针访问结构体中的属性，需要使用‘->’
	cout << " 姓名： " << p->name << " 年龄： " << p->age << " 分数： " << p->score << endl;

	system ("pause");
	return 0;
}

8.5 结构体嵌套结构体

**作用：**结构体成员可以是另一个结构体

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

示例：

//结构体嵌套结构体
//定义学生结构体
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 = 9;
	t.name = "大王";
	t.age = 40;
	t.stu.name = "小王";
	t.stu.age = 20;
	t.stu.score = 80;

	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;

//定义学生结构体
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 = 150;	//地址传递会改变实参的值
	cout << "子函数2中学生姓名： " << p->name << " 年龄： " << p->age << " 分数： " << p->score << endl;
}

int main ()
{
	//结构体做函数参数
	//将学生传入到一个参数中，打印学生的所有信息

	//创建结构体参数变量
	student s;
	s.name = "张三";
	s.age = 20;
	s.score = 90;

	//printStudent1(s);
	printStudent2 (&s);

	//主函数中打印学生信息
	cout << " 主函数中学生姓名： " << s.name << " 学生年龄： " << s.age << " 学生分数： " << s.score << endl;

	system ("pause");
	return 0;
}

8.7 结构体中const的使用

作用：用const来防止误操作

示例：

//const的使用场景

struct student
{
	string name;
	int age;
	int score;

};
//将函数中的形参改为指针，可以减少内存空间，而且不会复制新的副本
void printStudent (const student *s)	//加入const防止误操作
{
	//s->age = 23;	//加入const后，一旦有修改操作后就会报错，可以防止我们误操作
	cout << "姓名： " << s->name << " 年龄： " << s->age << " 分数： " << s->score << endl;
}

int main ()
{
	//创建结构体变量
	struct student s = { "张三",20,90 };

	//通过函数打印结构体变量信息

	printStudent (&s);



	system ("pause");
	return 0;
}

8.8 结构体案例

8.8.1 案例1：

案例描述：

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

设计学生和老师的结构体，其中在老师的结构体中，有老师姓名和一个存放5位学生的数组作为成员；学生的成员有姓名和分数；创建数组存放3名老师，通过函数给每位老师及所带学生赋值；最终打印老师数据及老师所带学生数据。

示例：

//定义学生结构体
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 <<
				"\t学生分数： " << 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;
}

总结：整理思路：

首先给定义老师和学生的结构体
创建老师的结构体数组
通过函数allocateSpace给老师及所带学生信息赋值（利用for循环）以数组形式传递
通过函数printInfo打印老师和学生的全部信息
小点：利用随机数种子和随机数。

8.8.2 案例2

案例描述：

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

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

5名英雄信息如下：

		{ "刘备",23,"男" },
		{ "关羽",22,"男" },
		{ "张飞",20,"男" },
		{ "赵云",21,"男" },
		{ "貂蝉",19,"女" },

示例：

//定义英雄结构体
struct Hero
{
	string name;
	int age;
	string gender;
};

//冒泡排序函数
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 )
			{
				Hero temp = heroArray[j];//struct 可省略
				heroArray[j] = heroArray[j + 1];
				heroArray[j + 1] = temp;
			}
		}
	}
}

//打印排序后英雄信息
void printHero (struct Hero heroArray[],int len)
{
	cout << "排序后结果：" << endl;
	for( int i = 0; i < len; i++ )
	{
		cout << "姓名： " << heroArray[i].name << " 年龄： " << heroArray[i].age
			<< " 性别： " << heroArray[i].gender << endl;
	}

}

int main ()
{
	//1、设计一个英雄结构体
	//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].gender << endl;
	}

	//3、利用函数使用冒泡排序将英雄按照年龄升序排列
	bubbleSort (heroArray,len);

	//通过函数打印排序后结果
	printHero (heroArray,len);


	system ("pause");
	return 0;
}

出错原因：一开始写冒泡排序时，通过年龄对比只进行了年龄交换而不是元素交换。

总结：该案例中需掌握的知识点：

结构体的定义以及结构体数组的创建
如何将数组传递到函数里，在函数中使用冒泡排序交换元素
利用函数输出结果

方的言

关注

0
点赞
踩
3

收藏

觉得还不错? 一键收藏
0
评论
C++基础入门学习笔记

C++ 基础入门学习笔记1 C++ 初识1.1 变量意义：便于管理内存空间语法：数据类型变量 = 变量初始值；示例：int main(){ // 创建变量：数据类型变量名 = 变量初始值； int a = 10; cout << "a=" << a << endl; system("pause"); return 0;}1.2 常量作用：用于记录程序中不可更改的数据两种定义方式：1.#define 宏常量：#define 常量名常
复制链接

扫一扫