C++基础入门

本文档下载：PDF 、.mk

C++基础入门

1. 初识 C++

1.1 第一个 C++ 程序

编写 C++ 程序的步骤

创建项目
创建文件
编写代码
运行程序

1.1.1 创建项目

这里使用 Visual Studio 2022 作为主要的编辑器来开发 C++ 项目。

在这里插入图片描述

1.1.2 创建文件

在这里插入图片描述

1.1.3 编写代码

#include <iostream>
using namespace std;

int main() {
    
    

	cout << "Hello World" << endl;

	system("pause");

	return 0;
}

1.1.4 运行程序

在这里插入图片描述

运行结果

在这里插入图片描述

1.2 注释

作用： 在代码中添加解释说明，方便自己或他人阅读代码；

两种格式：

扫描二维码关注公众号，回复： 15620018 查看本文章

单行注释：// 描述信息

通常在代码上一行，或者一条语句的末尾，对改行代码进行说明。
多行注释：/* 描述信息 */

通常放在一段代码上方，对该代码段进行说明。

Note: 编译器在编译代码时，会忽略掉注释内容。

#include <iostream>
using namespace std;

// 1. 单行注释

// 2. 多行注释

/*
	main 是一个程序的入口
	每个程序都有且仅有一个 main 函数
*/
int main() {
    
    

	// 在屏幕中输出 Hello World
	cout << "Hello World" << endl;

	system("pause");

	return 0;
}

1.3 变量

作用： 给一段指定的内存空间起名，方便操作这段内存。

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

变量的命名规范：

在名称中只能使用字母字符、数字和下划线（_）
名称的第一个字符不能是数字
区分大写字符与小写字符
不能将C++关键字用作名称
以两个下划线或下划线和大写字母打头的名称被保留给实现（编译器及其使用的资源）使用。以一个下划线开头的名称被保留给实现，用作全局标识符。
C++对于名称的长度没有限制，名称中所有的字符都有意义，但有些平台有长度限制。

示例：

#include <iostream>
using namespace std;

int main() {
    
    

	// 变量创建的语法: 数据类型 变量名 = 变量初始值;

	int a = 10;

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

	system("pause");

	return 0;
}

1.4 常量

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

两种定义常量的方式：

宏常量：#define 常量名常量值
- 通常在文件上方定义，表示一个常量。
const 修饰的变量：const 数据类型常量名 = 常量值;
- 通常在变量前加 const 关键字，修饰该变量为常量，不可修改。

示例：

#include <iostream>
using namespace std;

/*
	常量定义的方式
	1. #define 宏常量
	2. const 修饰的变量
*/

// 1. #define 宏常量
#define DAY 7

int main() {
    
    
	
	cout << "一周共 " << DAY << " 天！" << endl;
	// DAY = 8;   // 报错，常量不可修改！

	// 2. const 修饰的变量
	const int month = 12;
	cout << "一年共 " << month << " 月！" << endl;
	// month = 24; // 报错，常量不可修改！ 

	system("pause");

	return 0;
}

1.5 关键字

作用： 关键字是 C++ 中预先保留的单词 (标识符) ；

Note：在定义变量或者常量是不能使用关键字。

关键字如下：

asm	do	if	return	typedef
auto	double	inline	short	typeid
bool	dynamic_cast	int	signed	typename
break	else	long	sizeof	union
case	enum	mutable	static	unsigned
catch	explicit	namespace	static_cast	using
char	export	new	struct	virtual
class	extern	operator	switch	void
const	false	private	template	volatile
const_cast	float	protected	this	wchar_t
continue	for	public	throw	while
default	friend	register	true
delete	goto	reinterpret_cast	try

各关键字用途。

1.6 标识符命名规范

作用： C++ 规定给标识符 (变量、常量) 命名时，有一套自己的规则

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

Note：给标识符命名时，尽量做到见名知意的效果，方便自己和他人阅读。

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)

#include <iostream>
using namespace std;

int main() {
    
    
	// 1. 短整型
	short num1 = 10;
	// 2. 整型
	int num2 = 10;
	// 3. 长整形
	long num3 = 10;
	// 4. 长长整型
	long long num4 = 10;

	cout << "num1 = " << num1 << "; num1 占 " << sizeof(num1) << " 字节" << endl;
	cout << "num2 = " << num2 << "; num2 占 " << sizeof(num2) << " 字节" << endl;
	cout << "num3 = " << num3 << "; num3 占 " << sizeof(num3) << " 字节" << endl;
	cout << "num4 = " << num4 << "; num4 占 " << sizeof(num4) << " 字节" << endl;

	system("pause");

	return 0;
}

运行结果：
在这里插入图片描述

2.2 sizeof关键字

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

语法：sizeof(数据类型 or 变量)

#include <iostream>
using namespace std;

int main() {
    
    

	cout << "short     占 " << sizeof(short) << " 字节" << endl;
	cout << "int       占 " << sizeof(int) << " 字节" << endl;
	cout << "long      占 " << sizeof(long) << " 字节" << endl;
	cout << "long long 占 " << sizeof(long long) << " 字节" << endl;

	system("pause");

	return 0;
}

在这里插入图片描述

2.3 实型 (浮点型)

作用： 用于表示小数。

浮点型分为两种：

单精度：float
双精度：double

两者的区别在于表示的有效数字范围不同。

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

#include <iostream>
using namespace std;

int main() {
    
    

	/*
		1. 单精度：float
		2. 双精度：double
	*/

	float f_num1 = 3.14f;
	double d_num2 = 3.14;

	// 默认情况下输出一个小数只会显示 6 位有效数字
	cout << "f_num1 = " << f_num1 << "; f_num1 占 " << sizeof(f_num1) << " 字节" << endl;
	cout << "d_num2 = " << d_num2 << "; d_num2 占 " << sizeof(d_num2) << " 字节" << endl;

	// 科学计数法
	float f_num2 = 3e2;
	float f_num3 = 3e-2;
	cout << "f_num2 = " << f_num2 << endl;
	cout << "f_num3 = " << f_num3 << endl;

	system("pause");
	
	return 0;
}

运行结果：

在这里插入图片描述

2.4 字符型

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

语法： char ch = 'a';

Note：

在显示字符型变量时，用单引号将字符括起来，不能使用双引号。

单引号内只能有一个字符，不可以是字符串

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

#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 ch2 = 'abcdefg';  // 创建字符变量时，单引号内只能有一个字符

	// 4. 字符型变量对应的 ASCII 码
	cout << "a 的ASCII 码：" << (int)ch << endl;
	system("pause");

	return 0;
}

2.5 转义字符

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

转义字符	含义	ASCII码值
\a	警报	007
\b	退格 (BS), 将当前位置移动到前一列	008
\f	换页 (FF), 将当前位置移动到下页开头	012
\n	换行 (LF), 将当前位置移动到下行开头	010
\r	回车 (CR), 将当前位置移动到本行开头	013
\t	水平制表 (HT), 跳到下一个 TAB 位置	009
\v	垂直指标 (VT)	011
\\	代表一个反斜杠字符	092
\’	代表一个单引号字符	039
\"	代表一个双引号字符	034
?	代表一个问号	063
\0	数字0	000
\ddd	8进制转义字符，d 范围 0~7	3位8进制
\xhh	16 进制转义字符，h 范围 0_9，AF，a~f	3位16进制

#include <iostream>
using namespace std;

int main() {
    
    
	// 转义字符

	// 换行符 \n
	cout << "Hello World \n";

	// 反斜杠 \\

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

	system("pause");

	return 0;
}

2.6 字符串型

作用： 用于表示一串字符

两种风格：

C 语言风格：char 变量名[] = "字符串值";
C++ 风格：string 变量名 = "字符串值"; 需要包含头文件 <string>。

#include<iostream>
#include<string>
using namespace std;

int main() {
    
    
	// 1. C 语言风格字符串
	char str[] = "Hello World!";
	cout << str << endl;

	// 2. C++ 风格字符串
	string str1 = "Hello World!";
	cout << str << endl;

	system("pause");
	return 0;
}

2.7 布尔类型 bool

作用： 布尔数据类型代表真或假的值

bool 类型只有两个值：

true：真 (本质是 1)
false：假 (本质是 0)

bool 类型占 1 个字节大小

#include<iostream>
using namespace std;

int main() {
    
    
	bool flag = true;
	cout << flag << endl;

	flag = false;
	cout << flag << endl;

	cout << "size of bool: " << sizeof(bool) << endl;

	system("pause");
	return 0;
}

2.8 数据的输入

作用： 用于从键盘获取数据

关键字： cin

语法： cin >> 变量

#include<iostream>
using namespace std;

int main() {
    
    
	int a = 0;
	cout << "输入一个整数 a = " << endl;
	cin >> a;
    cout << "a = " << a << endl;

	system("pause");
	return 0;
}

3. 运算符

作用： 用于执行代码的运算。

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

3.1 算数运算符

作用： 用于处理四则运算

运算符	术语	示例	结果
+	正号	+3	3
-	负号	-4	4
+	加好	1+2	3
-	减号	4-2	2
*	乘号	2*4	8
/	除号	10/5	2
%	取余 (取模)	10/5	0
++	前置递增	a=2; b=++a;	a=3; b=3;
++	后置递增	a=2; b=a++;	a=3; b=2;
–	前置递减	a=3; b=–a;	a=2; b=2;
–	后置递减	a=3; b=a–;	a=2; b=3;

#include<iostream>
using namespace std;

int main() {
    
    
	//加减乘除
	int a = 20;
	int b = 6;
	cout << "a + b = " << a + b << endl;
	cout << "a - b = " << a - b << endl;
	cout << "a * b = " << a * b << endl;
	cout << "a / b = " << a / b << endl; // 两个整数相除，得到的结果也是整数 a / b=3
	cout << "a % b = " << a % b << endl; // a % b = 2; 两个小数不能做取模运算
	cout << "a++ = " << a++ << "; a = " << a << endl; // 后置递增，先进行表达式运算，后让变量 +1 
	cout << "++b = " << ++b << "; b = " << b << endl; // 前置递增，先让变量 +1 然后进行表达式的运算

	system("pause");
	return 0;
}

运行结果：

a + b = 26
a - b = 14
a * b = 120
a / b = 3
a % b = 2
a++ = 20; a = 21
++b = 7; b = 7

3.2 赋值运算

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

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

#include<iostream>
using namespace std;

int main() {
    
    

	int a = 10;

	// 赋值 =
	a = 100;
	cout << "a = " << a << endl;

	// 加等于 +=
	a = 10;
	a += 3; // a = a + 3;
	cout << "a = " << a << endl;

	// 减等于 -=
	a = 10;
	a -= 3; // a = a - 3;
	cout << "a = " << a << endl;

	// 除等于 /=
	a = 10; 
	a /= 3; // a = a / 3;
	cout << "a = " << a << endl;

	// 模等于 %=
	a = 10;
	a %= 3; // a = a % 3;
	cout << "a = " << a << endl;

	system("pause");
	return 0;
}

运算结果：

a = 100
a = 13
a = 7
a = 3
a = 1

3.3 比较运算符

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

运算符	术语	示例	结果
==	等于	4 == 3;	0
!=	不等于	4 != 2;	1
<	小于	3 < 4;	1
>	大于	4 > 3;	0
<=	小于等于	5<=5;	1
>=	大于等于	5>=6;	0

#include<iostream>
using namespace std;

int main() {
    
    

	int a = 10;
	int b = 20;

	cout << "a == b result is " << (a == b) << endl;
	cout << "a != b result is " << (a != b) << endl;
	cout << "a < b  result is " << (a < b) << endl;
	cout << "a > b  result is " << (a > b) << endl;
	cout << "a <= b result is " << (a <= b) << endl;
	cout << "a >= b result is " << (a >= b) << endl;

	system("pause");
	return 0;
}

运算结果：

a == b result is 0
a != b result is 1
a < b result is 1
a > b result is 0
a <= b result is 1
a >= b result is 0

3.4 逻辑运算符

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

运算符	术语	示例	结果
!	非	!a	如果 a 为假，则 !a 为真；如果 a 为真，则 !a 为假。
&&	与	a && b	如果 a 和 b 都为真，则结果为真，否则为假。
\|\|	或	a \|\| b	如果 a 和 b 都为假，则结果为假，否则为真。

#include<iostream>
using namespace std;

int main() {
    
    

	int a = 10;
	// 在 C++ 中除了 0 都为真
	// 逻辑非
	cout << "!a = " << !a << endl;
	cout << "!!a = " << !!a << endl;

	// 逻辑与
	int b = 1;
	cout << "a && b = " << (a && b) << endl;
	b = 0;
	cout << "a && b = " << (a && b) << endl;

	// 逻辑或
	int c = 0;
	cout << "b || c = " << (b || c) << endl;
	c = 1;
	cout << "b || c = " << (b || c) << endl;

	system("pause");
	return 0;
}

运算结果：

!a = 0
!!a = 1
a && b = 1
a && b = 0
b || c = 0
b || c = 1

4. 程序流程结构

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

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

4.1 选择结构

4.1.1 if 语句

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

if 语句的三种形式：

单行格式 if 语句：if(条件){条件满足执行的语句}

在这里插入图片描述

#include<iostream>
using namespace std;

int main() {
    
    

// 选择结构，单行 if 语句
// 1. 用户输入年龄
int age = 0;

cout << "请输入年龄：" << endl;
cin >> age;

// 2. 判断年龄是都大于等于 18，如果大于 18 输出：你已经成年了！
if (age >= 18) {
    
    
    cout << "你已经成年了！" << endl;
}

system("pause");
return 0;
}

多行格式 if 语句：if(条件){条件满足时执行的语句}else{条件不满足时执行的语句}

在这里插入图片描述

#include<iostream>
using namespace std;

int main() {
    
    
	// 选择结构，多行 if 语句

	// 1. 用户输入年龄
	int age = 0;

	cout << "请输入你的年龄：" << endl;
	cin >> age;
	// 2. 年龄大于等于 18，输出你已经成年了
	if (age >= 18) {
    
    
		cout << "你已经成年了！" << endl;
	}
	// 3. 年龄小于 18，输出你还是未成年
	else {
    
    
		cout << "你还是未成年！" << endl;
	}

	system("pause");
	return 0;
}

多条件的 if 语句：if(条件1){满足条件1执行的语句}else(条件2){满足条件2执行的语句}...else{以上条件都不满足时执行的语句}

#include<iostream>
using namespace std;

int main03() {
    
    
	// 选择结构，多条件 if 语句

	// 1. 输入高考成绩
	int socre;
	cout << "请输入你的高考成绩：" << endl;
	cin >> socre;

	// 2. 成绩大于 600， 考上 985
	if (socre > 600) {
    
    
		cout << "你考上了 985" << endl;
	}
	// 3. 成绩大于 500， 考上 211
	else if(socre > 500){
    
    
		cout << "你考上了 211" << endl;
	}
	// 4. 成绩大于 400， 考上普通大学
	else if (socre > 400) {
    
    
		cout << "你考上了普通大学" << endl;
	}
	// 5. 否则没有考上大学
	else{
    
    
		cout << "你没考上大学" << endl;
	}

	system("pause");
	return 0;
}

嵌套 if 语句： 在 if 语句中，可以嵌套使用 if 语句，达到更精确的条件判断

#include<iostream>
using namespace std;

int main() {
    
    
	// 选择结构，嵌套 if 语句

	// 1. 输入高考成绩
	int score = 0;
	cout << "请输入你的高考成绩：" << endl;
	cin >> score;

	// 2. 成绩大于 600， 考上 985
	if (score > 600) {
    
    
		cout << "你考上了 985！" << endl;
		// 3. 成绩大于 700， 考上 北大
		if (score > 700) {
    
    
			cout <<"你的成绩是：" << score << " ，你考上了 北大。" << endl;
		}
		// 4. 成绩大于 650， 考上 清华
		else if (score > 650)
		{
    
    
			cout << "你的成绩是：" << score << " ，你考上了 清华。" << endl;
		}
		// 5. 否则考上 人大
		else {
    
    
			cout << "你的成绩是：" << score << " ，你考上了 人大。" << endl;
		}
	}

	system("pause");
	return 0;
}

练习：选出三个数中的最大值。

#include<iostream>
using namespace std;

int main() {
    
    

	int a[3] = {
    
     0 };
	cout << "请输入三个数：" << endl;
	cout << "A = ";
	cin >> a[0];
	cout << "B = ";
	cin >> a[1];
	cout << "C = ";
	cin >> a[2];

	if (a[0] > a[1]) {
    
    
		if (a[0] > a[2]) {
    
    
			cout << "A 是最大值。" << endl;
		}
		else
		{
    
    
			cout << "C 是最大值。" << endl;
		}
	}
	else
	{
    
    
		if (a[1] > a[2]) {
    
    
			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() {
    
    
	// 三目运算符

	int a[3] = {
    
     0 };
	cout << "请输入三个数：" << endl;
	cout << "A = ";
	cin >> a[0];
	cout << "B = ";
	cin >> a[1];
	cout << "C = ";
	cin >> a[2];

	// 在C++中，三目运算符返回的是变量，可以继续赋值。
	cout << "最大值是：" << ((a[0] > a[1] ? a[0] : a[1]) > a[2] ? (a[0] > a[1] ? a[0] : a[1]) : a[2]) << endl;

	system("pause");
	return 0;
}

4.1.3 switch 语句

作用： 执行多条件语句

语法：

switch(表达式){
    
    
    case 结果1:
        执行语句;
        break;
    case 结果2:
        执行语句;
        break;
    case 结果3:
        执行语句;
        break;
    ···
    default:
        执行语句;
}

#include<iostream>
using namespace std;

int main() {
    
    
  
	// switch 语句

	// 1. 输入电影评分
	int level = 0;
	cout << "请输入你对这部电影的评分(0-10)：";
	cin >> level;

	// 2. 评分标准
	switch (level) {
    
    
		// 9，10 经典
	case 10:
	case 9:
		cout << "你认为这部电影很经典！" << endl;
		break;
		// 7，8 非常好
	case 8:
	case 7:
		cout << "你认为这部电影非常好！" << endl;
		break;
		// 5,6 一般
	case 6:
	case 5:
		cout << "你认为这部电影一般！" << endl;
		// 低于 5 分 烂片
	default:
		cout << "你认为这部电影是烂片！" << endl;
	}

	system("pause");
	return 0;
}

4.2 循环结构

4.2.1 while 循环语句

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

语法： while(循环条件){循环语句}

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

在这里插入图片描述

#include<iostream>
using namespace std;

int main() {
    
    

	// while 循环
	// 打印 0~9 这 10 个数字
	int i = 0;
	while (i < 10) {
    
    
		cout << i++ << endl;
	}

	system("pause");
	return 0;
}

案例：猜数字

#include<iostream>
using namespace std;

int main() {
    
    

	// 1. 生成随机数
	int num = rand()%100+1; // 生成 1-100 的随机数
	// 2. 玩家猜测
	int guset_num = 0;
	cout << "请输入你猜的数字（1—100）：";
	cin >> guset_num;
	// 3. 判断猜测结果
	while (num != guset_num)
	{
    
    
		if (num < guset_num)
		{
    
    
			cout << "你猜大了，请再次尝试！" << endl;
		}
		else {
    
    
			cout << "你猜小了，请再次尝试！" << endl;
		}
		cout << "请输入你猜的数字（1—100）：";
		cin >> guset_num;
	}
	cout << "恭喜你，猜对了！" << endl;
	system("pause");
	return 0;
}

4.2.2 do…while 循环语句

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

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

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

在这里插入图片描述

#include<iostream>
using namespace std;

int main() {
    
    

	// 打印 0-9
	int i = 0;
	do
	{
    
    
		cout << i++ << endl;
	} while (i < 10);

	system("pause");
	return 0;
}

案例：寻找三位数的水仙花数。

#include<iostream>
using namespace std;

int main() {
    
    

	// 打印三位数中的水仙花数
	int num = 100;
	int a[3] = {
    
     0 };
	do {
    
    
		a[2] = num % 10;          // 个位
		a[1] = (num / 10) % 10;   // 十位
		a[0] = (num / 100) % 10;  // 百位
		if ( a[0] * a[0] * a[0] + a[1] * a[1] * a[1] + a[2] * a[2] * a[2] == num) {
    
    
			cout << num << endl;
		}
		num++;
	} while (num<1000);

	system("pause");
	return 0;
}

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

案例：逢七过

#include<iostream>
using namespace std;

int main() {
    
    

	// 100 以内逢7必过
	for (int i = 1; i < 100; i++) {
    
    
        //  个位是 7        十位是 7        7 的倍数
		if (i % 10 == 7 || i / 10 == 7 || i % 7 == 0) {
    
    
			cout << i << "：过" << endl;
		}
	}

	system("pause");
	return 0;
}

4.2.4 嵌套循环

作用： 在循环体中再嵌套一层循环，解决某些问题

案例：乘法口诀表

#include<iostream>
using namespace std;

int main() {
    
    

	// 乘法口诀表
	// 行
	for (int row = 1; row < 10; row++) {
    
    
		// 列
		for (int columns = 1; columns <= row; columns++) {
    
    
			cout << row << " * " << columns << " = " << row * columns << "  ";
		}
		cout << endl;
	}
	system("pause");
	return 0;
}

4.3 跳转语句

4.3.1 break语句

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

break 的使用时机：

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

4.3.2 continue 语句

作用： 在循环语句中，跳过本次循环中余下尚未执行的语句，继续执行下一次循环。

4.3.3 goto 语句

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

语法： goto 标记;

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

#include<iostream>
using namespace std;

int main() {
    
    

	for (int i = 0; i < 10; i++) {
    
    
		cout << i << endl;
		if (i == 5) {
    
    
			goto FLAG;
		}
	}

FLAG:
	cout << "goto 14nd line." << endl;

	system("pause");
	return 0;
}

5. 数组

5.1 概述

数组就是存放了相同类型的数据元素集合。

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

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

5.2 一维数组

5.2.1 一维数组的定义方式

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

数据类型数组名[数组长度];
数据类型数组名[数组长度] = { 值1, 值2, 值3,···};
数据类型数组名[] = { 值1, 值2, 值3,···};

#include<iostream>
using namespace std;

int main() {
    
    

	/*
	* 1. 数据类型 数组名[数组长度];
	* 2. 数据类型 数组名[数组长度] = { 值1, 值2, 值3,···};
	* 3. 数据类型 数组名[] = { 值1, 值2, 值3,···};
	*/

	// 1. 数据类型 数组名[数组长度];
	int arr1[5];
	// 给数组中的各个元素赋值
	// 数组的下表从 0 开始
	arr1[0] = 10;
	arr1[1] = 20;
	arr1[2] = 30;
	arr1[3] = 40;
	arr1[4] = 50;
	// 打印 arr1 数组中的各个元素的值
	cout << arr1[0] << endl;
	cout << arr1[1] << endl;
	cout << arr1[2] << endl;
	cout << arr1[3] << endl;
	cout << arr1[4] << endl;

	// 2. 数据类型 数组名[数组长度] = { 值1, 值2, 值3,···};
	// 初始化数据时，如果没有全部填写完，会用 0 来填补
	int arr2[5] = {
    
     10,20,30,40,50 };
	// 打印 arr2 数组中的各个元素的值
	cout << arr2[0] << endl;
	cout << arr2[1] << endl;
	cout << arr2[2] << endl;
	cout << arr2[3] << endl;
	cout << arr2[4] << endl;

	// 3. 数据类型 数组名[] = { 值1, 值2, 值3,···};
	int arr3[] = {
    
     10,20,30,40,50,60 };
	// 打印 arr3 数组中的各个元素的值
	for (int i = 0; i < sizeof(arr3) / sizeof(int); i++) {
    
    
		cout << arr3[i] << endl;
	}

	system("pause");
	return 0;
}

数组下标从 0 开始索引。

5.2.3 一维数组数组名

一维数组名称的用途：

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

#include<iostream>
using namespace std;

int main() {
    
    

	int arr[10] = {
    
     20,40,60,80 };
	
	// 1. 可以统计整个数组在内存中的长度
	cout << "整个数组占用内存空间为：" << sizeof(arr) << endl;
	cout << "每个元素占用内存空间为：" << sizeof(arr[0]) << endl;
	cout << "数组中的元素个数为：" << sizeof(arr)/sizeof(arr[0]) << endl;
	
	// 2. 可以获取数组在内存中的首地址
	cout << "数组首地址为：" << arr << endl;
	cout << "第二个元素的地址为：" << &arr[1] << endl;

	system("pause");
	return 0;
}

案例：比较五个数的最大值

#include<iostream>
using namespace std;

int main() {
    
    

	int arr[5];
	int max = LONG_MIN;
	cout << "请输入 5 个数：" << endl;
	for (int i = 0; i < 5; i++) {
    
    
		cout << "第 " << i+1 << " 位数：";
		cin >> arr[i];
		if (max < arr[i]) {
    
    
			max = arr[i];
		}
	}
	cout << "最大值是：" << max << endl;

	system("pause");
	return 0;
}

案例：数组元素逆置

#include<iostream>
using namespace std;

int main() {
    
    

	int arr[] = {
    
     1,2,3,4,5,6,7,8 };
	int length = sizeof(arr) / sizeof(int);
	for (int i = 0; i < length / 2; i++) {
    
    
		int temp = arr[i];
		arr[i] = arr[length - i - 1];
		arr[length - i - 1] = temp;
	}
	for (int i = 0; i < length; i++)
	{
    
    
		cout << arr[i] << endl;
	}

	system("pause");
	return 0;
}

5.2.3 冒泡排序

作用： 最常用的排序算法，对数组内元素进行排序。

比较相邻的两个元素，如果第一个比第二个大则交换他们两个。
对每一对相邻元素做同样的工作，执行完成后找对第一个最大值。
重复以上的步骤，每次比较次数 -1，知道不需要比较。

#include<iostream>
using namespace std;

int main() {
    
    

	int arr[] = {
    
     2,1,4,3,6,5,7,9,8,0 };
	// 排序轮数
	for (int i = 0; i < 10-1; i++) {
    
    
		// 对比次数
		for (int j = 0; j < 10-i-1; 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 < 10; i++)
	{
    
    
		cout << arr[i] << " ";
	}
	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. 数据类型 数组名[行数][列数];
	2. 数据类型 数组名[行数][列数] = {
    
    { 数据1, 数据2}, {数据3, 数据4}};
	3. 数据类型 数组名[行数][列数] = { 数据1, 数据2, 数据3, 数据4};
	4. 数据类型 数组名[][列数] = { 数据1, 数据2, 数据3, 数据4};
	*/

	// 1. 数据类型 数组名[行数][列数];
	int arr1[2][3];
	arr1[0][0] = 1;
	arr1[0][1] = 2;
	arr1[0][2] = 3;
	arr1[1][0] = 4;
	arr1[1][1] = 5;
	arr1[1][2] = 6;

	cout << "打印arr1：" << endl;
	// 行
	for (int i = 0; i < 2; i++)
	{
    
    
		// 列
		for (int j= 0; j < 3; j++)
		{
    
    
			cout << arr1[i][j] << "  ";
		}
	}
	cout << endl;

	// 2. 数据类型 数组名[行数][列数] = {
    
    { 数据1, 数据2}, {数据3, 数据4}};
	int arr2[2][3] = {
    
     {
    
     7, 8, 9},{
    
     10, 11, 12} };
	cout << "打印arr2：" << endl;
	// 行
	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] = {
    
     13, 14, 15, 16, 17, 18};
	cout << "打印arr3：" << endl;
	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] = {
    
     19, 20, 21, 22, 23, 24 };
	cout << "打印arr4：" << endl;
	for (int i = 0; i < 2; i++)
	{
    
    
		// 列
		for (int j = 0; j < 3; j++)
		{
    
    
			cout << arr4[i][j] << "  ";
		}
	}
	cout << endl;

	system("pause");
	return 0;
}

5.3.2 二维数组的应用

计算每个同学的总成绩。

	语文	数学	英语
张三	100	90	98
李四	78	89	98
王五	88	86	66

#include<iostream>
using namespace std;
#include<string>

int main() {
    
    

	int scores[3][3] = {
    
    
		{
    
     100, 90, 98},
		{
    
     78, 89, 98},
		{
    
     88, 86, 66}
	};
	string name[3] = {
    
     "张三", "李四", "王五" };
	int sum[3] = {
    
     0 };
	for (int i = 0; i < 3; i++)
	{
    
    
		for (int j = 0; j < 3; j++)
		{
    
    
			sum[i] += scores[i][j];
		}
		cout << name[i]<< "同学的总分：" << sum[i] << endl;
	}
	system("pause");
	return 0;
}

6. 函数

6.1 概述

作用： 将一段经常使用的代码封装起来，减少重复代码

一个较大的程序，一般分为若干个程序块，每个模块实现特定的功能。

6.2 函数的定义和调用

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

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

语法：

#include <iostream>
using namespace std;

// 函数定义
/*
    语法：
        返回值类型 函数名(参数列表){

            函数体语句;

            return 表达式;
        }
*/

// 求和函数，实现两个整数相加，并返回相加的结果
// 函数定义时参数列表是形参
int sum(int num1, int num2) {
    
    
    return num1 + num2;
}


int main()
{
    
    
    // 函数的调用
    // 函数调用语法：函数名称(参数列表)
    // 函数调用是参数列表是实参
    cout << sum(1, 2) << endl;
    system("pause");
    return 0;
}

6.3 值传递

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

#include <iostream>
using namespace std;

// 值传递
// 定义函数，实现两个数字的交换

// 如果函数不需要返回值，声明的时候可以写 void
void swap(int num1, int num2) {
    
    
    cout << "交换前 num1 = " << num1 << " num2 = " << num2 << endl;
    int temp;                
    temp = num1;             
    num1 = num2;             
    num2 = temp;             
    cout << "交换后 num1 = " << num1 << " num2 = " << num2 << endl;
    return;
}

int main()
{
    
    
    int a = 10;
    int b = 20;
    cout << "交换前 a = " << a << " b = " << b << endl;

    swap(a, b);
    // 值传递时，形参发生任何改变，实参不会发生改变
    cout << "交换后 a = " << a << " b = " << b<< endl;
    system("pause");
    return 0;
}

6.4 函数常见样式

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

#include<iostream>
using namespace std;

// 函数常见样式
// 1. 无参无返
void test01() {
    
    
	cout << "This is test01" << endl;
	return;
}
// 2. 无参有返
int test02() {
    
    
	cout << "This is test02" << endl;
	return 10;
}
// 3. 有参无返
void test03(int a) {
    
    
	cout << "This is test03, a = " << a << endl;
	return;
}
// 4. 有参有返
int test04(int a) {
    
    
	cout << "This is test04" << endl;
	return a;
}
int main() {
    
    
    
	system("pause");
	return 0;
}

6.5 函数的声明

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

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

#include<iostream>
using namespace std;

// 函数的声明
int max(int num1, int num2);

int main() {
    
    
	
	cout << max(1, 2) << endl;

	system("pause");
	return 0;
}

// 比较函数，实现两个整型数字进行比较,返回较大值
int max(int num1, int num2) {
    
    
	return num1 > num2 ? num1 : num2;
}

6.6 函数的分文件编写

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

函数分文件编写一般有 4 个步骤。

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

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

void swap(int num1, int num2);

// swap.cpp
#include "swap.h"

void swap(int num1, int num2) {
    
    
    cout << "swap.cpp 交换前 num1 = " << num1 << " num2 = " << num2 << endl;
    int temp = num1;
    num1 = num2;
    num2 = temp;
    cout << "swap.cpp 交换后 num1 = " << num1 << " num2 = " << num2 << endl;
    return;
}

// 函数的份文件编写.cpp
#include<iostream>
using namespace std;

#include "swap.h"

int main() {
    
    
    swap(10,20);
	system("pause");
	return 0;
}

7. 指针

7.1 指针的基本概念

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

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

7.2 指针变量的定义和使用

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

#include<iostream>
using namespace std;

int main() {
    
    

	// 1. 定义指针
	int a = 10;
	// 指针定义的语法 数据类型* 变量名;
	int* p;
	// 指针记录 a 的地址
	p = &a;

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

	system("pause");
	return 0;
}

7.3 指针所占的内存空间

32 位操作系统下，指针占 4 个字节
64 位操作系统下，指针占 8 个字节

#include<iostream>
using namespace std;
#include<string>

int main() {
    
    

	// 指针所占的内存空间
	int a = 10;
	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(string*) = " << sizeof(string*) << endl;

	system("pause");
	return 0;
}

7.4 空指针和野指针

空指针： 指针变量指向内存编号为 0 的空间。

用途： 初始化指针变量

空指针指向的内存变量是不可以访问的

#include<iostream>
using namespace std;

int main() {
    
    

	// 空指针
	// 1. 空指针用于给指针变量初始化
	int* p = NULL;
	// 2. 空指针不可以被访问
	// 内存编号为 0-255 为系统占用的内存，不允许用户访问
	// *p = 100; // 运行程序会报错
	system("pause");
	return 0;
}

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

#include<iostream>
using namespace std;

int main03() {
    
    

	// 野指针
	// 指针变量指向内存地址编号为 0x1100 的空间
	int* p = (int*)0x1100;
	cout << *p << endl;

	system("pause");
	return 0;
}

7.5 const 修饰指针

const 修饰指针的三种情况：

const 修饰指针：常量指针，指针的指向可以改，指针指向的内容不能改。const int* p;
const 修饰常量：指针常量，指针的指向不能改，指针指向的内容可以改。int* const p;
const 既修饰指针，又修饰常量，指针的指向不能改，指针指向的内容也不能改。const int* const p;

#include<iostream>
using namespace std;

int main() {
    
    

	int a = 10;
	int b = 20;

	// 1. const 修饰指针
	const int* p1 = &a;
	// *p1 = 10;      // 错误；指针指向的内容不可以改
	p1 = &b;          // 指针指向的可以改
	cout << *p1 << endl;

	// 2. const 修饰常量
	int* const p2 = &a;
	*p2 = 20;         // 指针指向的内容可以改
	// p2 = &a;       // 错误；指针的指向不可以改
	cout << *p2 << endl;

	// 3. const 既修饰指针又修饰常量
	const int* const p3 = &a;
	//*p3 = 40;		 // 错误；指针指向的内容不可以改
	//p3 = &b;		 // 错误；指针的指向不可以改

	system("pause");
	return 0;
}

7.6 指针和数组

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

#include<iostream>
using namespace std;

int main() {
    
    
	// 指针和数组
	int arr[] = {
    
     2,3,4,5,6 };
	int* p = arr; // 定义指针p，指向数组的首地址

	// 打印数组第一个元素
	cout << *p << endl;
	// 打印数组第二个元素；让指针后移四个字节
	cout << *(p + 1) << endl;

	system("pause");
	return 0;
}

7.7 指针和函数

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

#include<iostream>
using namespace std;

void swap(int* num1, int* num2) {
    
    
	int temp = *num1;
	*num1 = *num2;
	*num2 = temp;
}

int main() {
    
    

	int arr[2] = {
    
     2,3 };
	cout << "arr 交换前：" << arr[0] << " , " << arr[1] << endl;
	swap(arr[0], arr[1]);
	cout << "arr 交换后：" << arr[0] << " , " << arr[1] << endl;

	int a = 10, b = 20;
	cout << "a ,b 交换前：" << a << " , " << b << endl;
	swap(&a, &b);
	cout << "a ,b 交换后：" << a << " , " << b << endl;


	system("pause");
	return 0;
}

7.8 指针、数组和函数

案例：封装一个冒泡排序的函数，实现对数组的升序排序

#include<iostream>
using namespace std;

// 冒泡排序函数
void bobbleSort(int *arr, int len) {
    
     // int arr[] 也可以写成 int *arr
	for (int i = 0; i < len - 1; i++)
	{
    
    
		for (int j = 0; j < len - 1 - i; j++)
		{
    
    
			if (arr[j] > arr[j + 1]) {
    
    
				swap(arr[j], arr[j + 1]);
			}
		}
	}
}

// 交换两个数字
void swap(int* num1, int* num2) {
    
    
	int temp = *num1;
	*num1 = *num2;
	*num2 = temp;
}

int main() {
    
    

	int arr[10] = {
    
     9,3,2,1,6,4,7,8,5,0 };
	int len = sizeof(arr) / sizeof(int);
	bobbleSort(arr, len);
	for (int i = 0; i < len; i++)
	{
    
    
		cout << arr[i] << " ";
	}
	cout << endl;
	system("pause");
	return 0;
}

8. 结构体

8.1 结构体的基本概念

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

8.2 结构体的定义和使用

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

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

struct 结构体名变量名;
struct 结构体名变量名 = { 成员 1 值, 成员 2 值};
定义结构体时顺便创建变量

#include<iostream>
using namespace std;
#include<string>

// 创建学生类型的结构体
struct Student {
    
    
	string name;
	int age;
	int score;
}student3;   // 3. 定义结构体时顺便创建变量


int main() {
    
    
	// 创建具体的学生
	// 1. struct 结构体名 变量名;.
	// 创建结构体变量时 struct 关键字可以省略
	struct Student student1;
	// 给 student1 变量赋值，通过 . 访问结构体重的属性
	student1.name = "张三";
	student1.age = 17;
	student1.score = 99;

	cout << "姓名：" << student1.name << " 年龄：" << student1.age << " 分数：" << student1.score << endl;

	// 2. struct 结构体名变量名 = { 成员 1 值, 成员 2 值};
	struct Student student2 = {
    
    
		"李四",
		20,
		98
	};
	cout << "姓名：" << student2.name << " 年龄：" << student2.age << " 分数：" << student2.score << endl;
	// 3. 定义结构体时顺便创建变量
	student3.name = "王五";
	student3.age = 18;
	student3.score = 79;
	cout << "姓名：" << student3.name << " 年龄：" << student3.age << " 分数：" << student3.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. 创建结构体数组，并赋值
	Student stu[3] = {
    
    
		{
    
    "张三", 18, 97},
		{
    
    "李四", 20, 95},
		{
    
    "王五", 19, 96}
	};

	// 3. 遍历结构体数组
	for (int i = 0; i < 3; i++)
	{
    
    
		cout << "姓名：" << stu[i].name
			 << " 年龄：" << stu[i].age
			 << " 成绩：" << stu[i].score
			 << endl;
	}

	system("pause");
	return 0;
}

8.4 结构体指针

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

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

#include<iostream>
using namespace std;
#include<string>

// 结构体指针
// 1. 定义结构体
struct Student
{
    
    
	string name;
	int age;
	int score;
};

int main() {
    
    
	// 2. 创建学生结构体变量
	Student stu = {
    
     "张三", 19, 79 };

	// 3. 通过指针指向结构体变量
	Student* p = &stu;

	// 4. 通过指针访问结构体变量中的数据
	// 通过结构体指针访问结构中的属性，需要使用 ->
	cout << "姓名：" << p->name
		<< " 年龄：" << p->age
		<< " 成绩：" << p->score
		<< endl;
	system("pause");
	return 0;
}

8.5 结构体嵌套结构体

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

#include<iostream>
using namespace std;
#include<string>

// 结构体嵌套结构体
// 1. 定义结构体
struct Student
{
    
    
	string studentName;
	int studentAge;
	int score;
};
// 2. 定一个嵌套的结构体
struct Teacher {
    
    
	string teacherName;
	int teacherAge;
	Student stu;
};

int main() {
    
    
	// 3. 初始化嵌套类型的结构体
	Teacher teacher = {
    
     "赵老师",29,{
    
    "李四",13,97} };
    
    // 4. 遍历 teacher 的属性
	cout << "老师姓名：" << teacher.teacherName 
		 << " 老师年龄：" << teacher.teacherAge 
		 << " 学生姓名：" << teacher.stu.studentName 
		 << " 学生年龄：" << teacher.stu.studentAge 
		 << " 学生成绩：" << teacher.stu.score
		 << endl;
	system("pause");
	return 0;
}

8.6 结构体做函数参数

作用： 将结构体作为参数向函数中传递

传递的两种方式：

值传递
地址传递

#include<iostream>
using namespace std;
#include<string>

// 结构体做函数参数
// 1. 定义结构体
struct Student
{
    
    
	string name;
	int age;
	int score;
};
// 值传递, 打印学生信息
void printStudentInfo_value(Student stu) {
    
    
	stu.age = 20;
	cout << "printStudentInfo_value()" << endl 
		 << " 姓名：" << stu.name
		 << " 年龄：" << stu.age
		 << " 分数：" << stu.score
		 << endl;
}

// 地址传递，打印学生信息
void printStudentInfo_address(Student *stu) {
    
    
	stu->age = 24;
	cout << "printStudentInfo_address()" << endl
		<< " 姓名：" << stu->name
		<< " 年龄：" << stu->age
		<< " 分数：" << stu->score
		<< endl;
}
int main() {
    
    
	
	Student stu = {
    
     "张三", 18, 97 };
	
	printStudentInfo_value(stu);
	cout << "main()" << endl
		<< " 姓名：" << stu.name
		<< " 年龄：" << stu.age
		<< " 分数：" << stu.score
		<< endl;

	printStudentInfo_address(&stu);
	cout << "main()" << endl
		<< " 姓名：" << stu.name
		<< " 年龄：" << stu.age
		<< " 分数：" << stu.score
		<< endl;

	system("pause");
	return 0;
}

8.7 结构体中 const 的用法

作用： 用 const 来防止误操作

#include<iostream>
using namespace std;
#include<string>

// 结构体中 const 的使用场景
// 1. 定义结构体
struct Student
{
    
    
	string name;
	int age;
	int score;
};
// 将函数中的形参改为指针可以减少内存开销，不服赋值新的副本
void printStudentInfo(const Student* stu) {
    
      // 添加 const 是为了防止对数据误操作
	// stu->age = 24;        //不能对指针所指向的内容进行修改
	cout << "printStudentInfo_address()" << endl
		 << " 姓名：" << stu->name
		 << " 年龄：" << stu->age
		 << " 分数：" << stu->score
		 << endl;
}
int main() {
    
    
	
	Student stu = {
    
     "张三", 18, 97 };

	printStudentInfo(&stu);
	system("pause");
	return 0;
}

8.8 结构体案例

案例描述：

学校正在进行毕设，每位老师带领 5 个学生，总共有 3 名老师，需求如下。

设计学生和老师的结构体，其中在老师的结构体中，有老师姓名和一个存放 5 名学生的数组作为成员。

学生的成员有姓名、考试分数，创建数组存放 3 名老师，通过函数给每位老师及所带的学生赋值。

最终打印出老师数据以及老师所带学生的姓名和成绩。

#include<iostream>
using namespace std;
#include<string>
#include<ctime>

struct Student
{
    
    
	string studentName;
	int score;
};

struct Teacher
{
    
    
	string teacherName;
	Student stu[5];
};

void allocateSpace(Teacher* teacher, int len) {
    
    
	
	string name = "ABCDE";
	for (int i = 0; i < len; i++)
	{
    
    
		teacher[i].teacherName = "Teacher_";
		teacher[i].teacherName += name[i];
		for (int j = 0; j < 5; j++)
		{
    
    
			teacher[i].stu[j].studentName = "Student_";
			teacher[i].stu[j].studentName += name[j];
			teacher[i].stu[j].score = rand() % 61 + 40;
		}
	}
}

void printIofo(const Teacher* teacher,int len){
    
    
	for (int i = 0; i < len; i++)
	{
    
    
		cout << "老师姓名：" << teacher[i].teacherName << endl;
		for (int j = 0; j < 5; j++)
		{
    
    
			cout << "\t学生姓名：" << teacher[i].stu[j].studentName << " 成绩：" << teacher[i].stu[j].score << endl;
		}
	}
}
int main() {
    
    
	srand((unsigned int) time(NULL));
	Teacher teacher[3];

	int len = sizeof(teacher) / sizeof(Teacher);
    
    // 给老师和学生赋值
	allocateSpace(teacher,len);
	 
    // 打印老师和学生的信息
	printIofo(teacher, len);

	system("pause");
	return 0;
}

案例描述：

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

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

#include<iostream>
using namespace std;
#include<string>

struct Hero {
    
    
	string name;
	int age;
	string sex;
};
// 打印英雄信息
void printInfo(Hero hero[], int len) {
    
    
	for (int i = 0; i < len; i++)
	{
    
    
		cout << "姓名：" << hero[i].name
			<< " 年龄：" << hero[i].age
			<< " 性别：" << hero[i].sex 
			<< endl;
	}
}
// 按年龄排序
void bobbleSortFromAge(Hero hero[], int len) {
    
    
	for (int i = 0; i < len - 1; i++)
	{
    
    
		for (int j = 0; j < len-i-1; j++)
		{
    
    
			if (hero[j].age > hero[j+1].age) {
    
    
				Hero temp = hero[j];
				hero[j] = hero[j + 1];
				hero[j + 1] = temp;
			}
		}
	}
}
int main() {
    
    

	Hero hero[5] = {
    
    
		{
    
    "刘  备", 20, "男"},
		{
    
    "孙尚香", 43, "女"},
		{
    
    "花木兰", 34, "女"},
		{
    
    "张  飞", 42, "男"},
		{
    
    "赵  云", 41, "男"},
	};
	int len = sizeof(hero) / sizeof(Hero);
	// 打印初始数据
	cout << "打印英雄初始排列顺序" << endl;
	printInfo(hero, len);

	cout << endl;

	// 按年龄从大到小冒泡排序
	bobbleSortFromAge(hero, len);
	// 打印排序后的数据
	cout << "打印英雄按年龄排列后的顺序" << endl;
	printInfo(hero, len);

	system("pause");
	return 0;
}

中在老师的结构体中，有老师姓名和一个存放 5 名学生的数组作为成员。

学生的成员有姓名、考试分数，创建数组存放 3 名老师，通过函数给每位老师及所带的学生赋值。

最终打印出老师数据以及老师所带学生的姓名和成绩。

#include<iostream>
using namespace std;
#include<string>
#include<ctime>

struct Student
{
    
    
	string studentName;
	int score;
};

struct Teacher
{
    
    
	string teacherName;
	Student stu[5];
};

void allocateSpace(Teacher* teacher, int len) {
    
    
	
	string name = "ABCDE";
	for (int i = 0; i < len; i++)
	{
    
    
		teacher[i].teacherName = "Teacher_";
		teacher[i].teacherName += name[i];
		for (int j = 0; j < 5; j++)
		{
    
    
			teacher[i].stu[j].studentName = "Student_";
			teacher[i].stu[j].studentName += name[j];
			teacher[i].stu[j].score = rand() % 61 + 40;
		}
	}
}

void printIofo(const Teacher* teacher,int len){
    
    
	for (int i = 0; i < len; i++)
	{
    
    
		cout << "老师姓名：" << teacher[i].teacherName << endl;
		for (int j = 0; j < 5; j++)
		{
    
    
			cout << "\t学生姓名：" << teacher[i].stu[j].studentName << " 成绩：" << teacher[i].stu[j].score << endl;
		}
	}
}
int main() {
    
    
	srand((unsigned int) time(NULL));
	Teacher teacher[3];

	int len = sizeof(teacher) / sizeof(Teacher);
    
    // 给老师和学生赋值
	allocateSpace(teacher,len);
	 
    // 打印老师和学生的信息
	printIofo(teacher, len);

	system("pause");
	return 0;
}

案例描述：

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

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

#include<iostream>
using namespace std;
#include<string>

struct Hero {
    
    
	string name;
	int age;
	string sex;
};
// 打印英雄信息
void printInfo(Hero hero[], int len) {
    
    
	for (int i = 0; i < len; i++)
	{
    
    
		cout << "姓名：" << hero[i].name
			<< " 年龄：" << hero[i].age
			<< " 性别：" << hero[i].sex 
			<< endl;
	}
}
// 按年龄排序
void bobbleSortFromAge(Hero hero[], int len) {
    
    
	for (int i = 0; i < len - 1; i++)
	{
    
    
		for (int j = 0; j < len-i-1; j++)
		{
    
    
			if (hero[j].age > hero[j+1].age) {
    
    
				Hero temp = hero[j];
				hero[j] = hero[j + 1];
				hero[j + 1] = temp;
			}
		}
	}
}
int main() {
    
    

	Hero hero[5] = {
    
    
		{
    
    "刘  备", 20, "男"},
		{
    
    "孙尚香", 43, "女"},
		{
    
    "花木兰", 34, "女"},
		{
    
    "张  飞", 42, "男"},
		{
    
    "赵  云", 41, "男"},
	};
	int len = sizeof(hero) / sizeof(Hero);
	// 打印初始数据
	cout << "打印英雄初始排列顺序" << endl;
	printInfo(hero, len);

	cout << endl;

	// 按年龄从大到小冒泡排序
	bobbleSortFromAge(hero, len);
	// 打印排序后的数据
	cout << "打印英雄按年龄排列后的顺序" << endl;
	printInfo(hero, len);

	system("pause");
	return 0;
}

C++ 基础入门

C++基础入门

1. 初识 C++

1.1 第一个 C++ 程序

1.1.1 创建项目

1.1.2 创建文件

1.1.3 编写代码

1.1.4 运行程序

1.2 注释

1.3 变量

1.4 常量

1.5 关键字

1.6 标识符命名规范

2. 数据类型

2.1 整型

2.2 sizeof关键字

2.3 实型 (浮点型)

2.4 字符型

2.5 转义字符

2.6 字符串型

2.7 布尔类型 bool

2.8 数据的输入

3. 运算符

3.1 算数运算符

3.2 赋值运算

3.3 比较运算符

3.4 逻辑运算符

4. 程序流程结构

4.1 选择结构

4.1.1 if 语句

4.1.2 三目运算符

4.1.3 switch 语句

4.2 循环结构

4.2.1 while 循环语句

4.2.2 do…while 循环语句

4.2.3 for 循环语句

4.2.4 嵌套循环

4.3 跳转语句

4.3.1 break语句

4.3.2 continue 语句

4.3.3 goto 语句

5. 数组

5.1 概述

5.2 一维数组

5.2.1 一维数组的定义方式

5.2.3 一维数组数组名

5.2.3 冒泡排序

5.3 二维数组

5.3.1 二维数组的定义方式

5.3.2 二维数组的应用

6. 函数

6.1 概述

6.2 函数的定义和调用

6.3 值传递

6.4 函数常见样式

6.5 函数的声明

6.6 函数的分文件编写

7. 指针

7.1 指针的基本概念

7.2 指针变量的定义和使用

7.3 指针所占的内存空间

7.4 空指针和野指针

7.5 const 修饰指针

7.6 指针和数组

7.7 指针和函数

7.8 指针、数组和函数

8. 结构体

8.1 结构体的基本概念

8.2 结构体的定义和使用

8.3 结构体数组

8.4 结构体指针

8.5 结构体嵌套结构体

8.6 结构体做函数参数

8.7 结构体中 const 的用法

8.8 结构体案例

猜你喜欢