c++基础入门

最新推荐文章于 2024-07-26 17:39:27 发布

努力不熬夜的小喵

最新推荐文章于 2024-07-26 17:39:27 发布

阅读量383

点赞数 1

文章标签： c++

本文链接：https://blog.csdn.net/qq_43569680/article/details/112391207

版权

本文详细介绍了C++的基础知识，包括变量、常量、数据类型、运算符、控制结构（如if、while、for循环）、函数、数组、指针、结构体等内容。还展示了如何定义和使用这些概念，以及在实际编程中的应用，如冒泡排序、数组元素交换等案例。此外，还探讨了指针和数组在函数调用中的作用，以及如何通过指针修改实参值。

摘要由CSDN通过智能技术生成

c++基础入门

1 c++初识

1.1 第一个c++程序

编写一个Hello world 程序：(注意main函数是程序的入口，有且只有一个)

#include <iostream>
using namespace std;
int main(){
cout << "Hello world" << endl;
system("pause");
return 0;
}

或者：

#include <iostream>
int main(){
std::cout << "Hello world" << std::endl;
system("pause");
return 0;
}

**"::"**表示作用域和所属关系：

表示全局作用符（::name）例:（::a）表示调用全局变量a
表示类作用府（class::name）例:（A::a）表示调用class A里的成员变量a
表示命名空间作用符（namespace::name）例:（std::cout）

1.2 注释

行注释：用“//”
块注释：用“/**/”

1.3 变量

变量是给一段内存空间进行命名，之后可通过对变量进行操作从而达到对空间内容进行操作的目的。

1.4 常量

常量是用于记录程序中不可更改的数据，有两种：

宏常量，用#define定义，且通常在文件上方进行定义(#define 常量名常量值)

#define day 7

const修饰的常量，修饰某个变量为常量，且不可修改(const 变量类型变量名=变量值)

const int day=7;

1.5 关键字

关键字是c++中预先保留的标识符，在定义常量或者变量的时候，不要用关键字
在这里插入图片描述
新增关键字：alignas、alignof、char16_t、char32_t、constexpr、decltype、noexcept、nullptr、static_assert、thread_local。

1.6 标识符的命名规则（尽量做到见名知义）

不能是关键字
区分大小写
由数字（不能作为开头）、字母、下划线组成

2 数据类型

在创建变量或者常量时必须指出相应的数据类型，否则无法给其分配内存
2.1 整型（整数类型的数据）
整型大小比较：short<int<=long(取决于操作系统是Windows还是Linux)<long long
在这里插入图片描述
2.2 sizeof关键字
统计数据类型所占内存大小(相当于求解字节大小)
语法：sizeof（数据类型/变量）

int main(){
std::cout << "int类型所占内存空间为：" << std::endl;
system("pause");
return 0;
}

**2.3 实型（浮点型）**表示小数

单精度float
双精度double
区别在于：表示的有效数字范围不同

（编译器遇见小数默认为是双精度，但是加上f就可以表示单精度）

int main(){
float a = 3.14;//编译器先默认是双精度，然后再进行转换，比加上f多了一步操作。
float b = 3.14f;
double c = 6.56;
cout << "a= " << a << " " ;
cout << "b= " << b << " " ;
cout << "c= " << c <<  endl;
system("pause");
return 0;
}

科学计数法表示：e2表示10的平方 e-2表示0.1的平方

float f1 = 3e2; // 3*10^2
cout << "f1= " << f1 << endl;
float f2 = 3e-2; // 3*0.1^2
cout << "f2= " << f2 << endl;

2.4 字符型(用于显示单个字符)
语法：char ch = ‘a’;
在这里插入图片描述

字符型变量对应的ASCII码值：a—97 A—65

#include <iostream>
using namespace std;
int main(){
char ch = 'a';
cout << ch << endl;//要想查看对应的ASCII码值，可以进行int的强制类型转换
cout << (int)ch << endl;//打印出对应的ASCII码值
cout << sizeof(ch) << endl;
cout << sizeof(char) << endl;
system("pause");
return 0;
}

2.5 转义字符
表示一些不能显示出来的ASCII字符，常用的有：\n \ \ \t

\n ：换行，将当前位置移到下一行开头
\\ ：代表一个反斜线字符
\t ：水平制表（跳到下一个TAB位置）有一个对齐的效果（和前面的多个字符拼接成8位）

2.6 字符串型（表示一串字符）
两种风格：

C风格：char 变量名[ ] = “字符串值”(注意[]；还有双引号)

#include <iostream>
using namespace std;
int main() {
	char str1[] = "hello world";
	cout << str1 << endl;
	system("pause");
	return 0;
}

C++风格：string 变量名 = “字符串值”（注意头文件）

#include <iostream>
#include <string>  //注意包含头文件
using namespace std;
int main() {
	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() {
	bool flag = false;
	cout << flag << " ";
	cout << sizeof(bool) << " ";
	cout << sizeof(flag) << endl;
	system("pause");
	return 0;
}

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

#include <iostream>
#include <string>
using namespace std;
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;
	cout << "ch的值对应的ASCII码值为： " << int(ch) << endl;
	//4.字符串型
	//c++方法
	string str1 = "abv";
	cout << "请给字符串型数str1赋值： " << endl;
	cin >> str1;
	cout << "str1的值为： " << str1 << endl;
	//c方法
	char str2[] = "abv";
	cout << "请给字符串型数str2赋值： " << endl;
	cin >> str2;
	cout << "str2的值为： " << str2 << endl;
	//5.布尔型
	bool flag = false;
	cout << "请给布尔型数flag赋值： " << endl;
	cin >> flag;
	cout << "flag的值为： " << flag << endl;
	system("pause");
	return 0;
}

3 运算符

3.1 算术运算符（处理四则运算）

两个整数相除，结果仍是整数，小数被去除了
两个数相除，除数不为0
两个数相除，有一个是浮点数，结果就可以是浮点数
% 取模运算（取余数）例：10%3=1
两个小数之间不能取模，只有整型变量才可以做取模运算
注意（++a/- - a)和（a++/a- -）的区别在于表达式的值不一样

3.2 赋值运算符（将表达式的值赋给变量）

= 赋值
+= /-= 加/减等于
*= / /= 乘/除等于
%= 取模等于

3.3 比较运算符（用于表达式的比较，并返回一个真值或者假值）

在这里插入图片描述

3.4 逻辑运算符（根据表达式的值返回真值或假值）

在这里插入图片描述

4 程序流程结构

C/C++都支持三种基本的程序运行结构：

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

4.1 选择结构

4.1.1 if语句

单行格式if语句：if（条件）{条件满足执行的语句}
if条件表达式后不要加分号

#include <iostream>
using namespace std;
int main() {
	int score = 0;
	cout << "请输入一个分数： " << endl;
	cin >> score;
	cout << "您输入的分数是： " << score << endl;
	if (score > 600) {
		cout << "恭喜你考上一本大学"<< endl;
	}
	cout << endl;
	system("pause");
	return 0;
}

多行格式if语句：if（条件）{条件满足执行的语句} else{条件不满足执行的语句}

#include <iostream>
using namespace std;
int main() {
	int score = 0;
	cout << "请输入一个分数： " << endl;
	cin >> score;
	cout << "您输入的分数是： " << score << endl;
	if (score > 600) {
		cout << "恭喜您考上一本大学"<< endl;
	}
	else
	{
		cout << "很遗憾，您未考上一本大学" << endl;
	}
	cout << endl;
	system("pause");
	return 0;
}

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

 #include <iostream>
using namespace std;
int main() {
	int score = 0;
	cout << "请输入一个分数： " << endl;
	cin >> score;
	cout << "您输入的分数是： " << score << endl;
	if (score > 600) {
		cout << "恭喜您考上一本大学"<< endl;
	}
	else if (score > 520) {
		cout << "恭喜您考上二本大学" << endl;
	}
	else 
	{
		cout << "很遗憾，您未考大学" << endl;
	}
	cout << endl;
	system("pause");
	return 0;
}

嵌套if语句：if语句里再包含了if
在这里插入图片描述

#include <iostream>
using namespace std;
int main() {
	int score = 0;
	cout << "请输入一个分数： " << endl;
	cin >> score;
	cout << "您输入的分数是： " << score << endl;
	if (score > 600) {
		if (score > 700)
		{
			cout << "恭喜您考上清华大学" << endl;
		}
		else if (score > 650)
		{
			cout << "恭喜您考上北京大学" << endl;
		}
		else if (score > 600)
		{
			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.2 三目运算符

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

表达式1为真则执行表达式2否则执行表达式3

#include <iostream>
using namespace std;
int main() {
    //创建三个变量 a b c
	//将a b 进行比较，将大的那个值赋值给变量c
	int a = 20;
	int b = 30;
	int c = 0;
	c = a > b ? a : b;
	cout << "c的值为： " << c << endl;
	system("pause");
	return 0;
}

#include <iostream>
using namespace std;
int main() {
    //在C++中三目运算符返回的是变量，可以继续赋值
	int a = 20;
	int b = 30;
	(a > b ? a : b) = 50;
	cout << "a的值为： " << a << "\n";
	cout << "b的值为： " << b << endl;
	system("pause");
	return 0;
}

4.1.3 switch语句

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

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

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

#include <iostream>
using namespace std;
int main() {
    //给电影打分（9-10 经典；7-8 非常好；5-6 一般； 5分以下 烂片）
	//1.提示用户给电影打分
	cout << "请输入对电影的评分： " << endl;
	//2.用户开始输入分数
	int score = 0;
	cin >> score;
	cout << "您输入的分数为： " << score << endl;
	//3.根据用户输入的分数来提示用户最后的结果
	switch (score) {
		case 10:
			cout << "您认为它是经典电影" << endl; 
			break;//用于退出当前分支
		case 9:
			cout << "您认为它是经典电影" << endl; 
			break;
		case 8:
			cout << "您认为电影非常好" << endl;
			break;
		case 7:
			cout << "您认为电影非常好" << endl; 
			break;
		case 6:
			cout << "您认为电影一般" << endl;
			break;
		case 5:
			cout << "您认为电影一般" << endl;
			break;
		default:
			cout << "您认为这是烂片" << endl;
	}
	system("pause");
	return 0;
}

4.2 循环结构

4.2.1 while循环结构

作用：满足循环条件，执行循环语句
语法：while（循环条件）{ 循环语句 }
解释：只要循环条件为真，就执行循环语句

using namespace std;
int main() {
	//while循环
	//在屏幕中打印 0-9 这10个数
	int num = 0;
	while (num <= 9) {
		cout << num << " ";
		num++;
	}
	cout << endl;
	system("pause");
	return 0;
}

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

#include <iostream>
using namespace std;
//time系统时间头文件包含
#include <ctime>
int main() {
	//此处的随机数是一个伪随机数，值一直都是一样的，要想使其真正的随机，方法如下：
	//添加随机数种子，利用当前系统时间生成随机数，防止每次随机数都是一样的 
	srand((unsigned int)time(NULL));
	//1.系统生成随机数
	int num = rand() % 100 +1; //rand()%100 是生成0-99的随机数 如果要生成1-100可以直接在后面加1
	cout << "这个随机数的值为：" << num << endl;
	//2.玩家进行猜测
	int val = 0;//玩家输入猜测值
	while (!(val==num))
	{
		cout << "请输入您的猜测：" << endl;
		cin >> val;
	//3.判断玩家的猜测
		if (val > num) {
			cout << "您猜测的数值为" << val << "偏大" << endl;
		}
		else if( val < num)
		{
			cout << "您猜测的数值为" << val << "偏小" << endl;
		}
		else 
		{
			cout << "您猜测的数值为" << val << "正确" << endl;
		}
	}
	//猜对 退出游戏
	//猜错 提示玩家过大或者过小 重新返回第二步
	system("pause");
	return 0;
}

4.2.2 do…while循环结构

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

#include <iostream>
using namespace std;
int main() {
	//do...while语句
	//在屏幕上输出0到9这十个数字
	int num = 0;
	do{
		cout << num << " ";
		num++;
	} while (num < 10);
	cout << endl;
	system("pause");
	return 0;
}

案例练习：水仙花数
案例描述：
水仙花数是指一个三位数，它每个位上的数字的3次幂之和等于它本身例如：1 ^ 3 + 5 ^ 3 +3 ^ 3 = 153
请利用do…while语句，求出所有三位数中的水仙花数。

#include <iostream>
using namespace std;
int main() {
	int num = 100;
	do {
		int a = 0;
		int b = 0;
		int c = 0;
		a = num % 10;//表示个位数
		b = num / 10 % 10;//表示十位数
		c = num / 100;//表示百位数
		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(起始表达式；条件表达式；末尾循环体 ) { 循环语句；}

#include <iostream>
using namespace std;
int main() {
	for (int i = 0; i <= 3; i++) {
		cout << i << " ";
	}
	cout << endl;
	system("pause");
	return 0;
}

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

#include <iostream>
using namespace std;
int main() {
	//1.先打印1-100的数
	//2.判断这个数个位是否含有7，或者数字十位是否含有7，或者该数字是否是7的倍数
	//3.将其结果打印输出
	for (int num = 1; num <= 100; num++) {
		if (num % 10 == 7 || num / 10 % 10 == 7 || num % 7 == 0) {
			cout << "敲桌子" << endl;
		}	
		else 
		{
			cout << num << endl;
		}
	}
	system("pause");
	return 0;
}

4.2.4 嵌套循环

在循环体中再裹一层循环，解决一些实际问题
例如，打印下图：

#include <iostream>
using namespace std;
int main() {
	//打印矩阵式的星图
	for (int i = 0; i < 9; i++) {
		for (int j = 0; j < 9; j++) {
			cout << "*" << "   ";
		}
		cout << endl;
	}
	//1.先打印一行
	//2.嵌套循环打印多行
	system("pause");
	return 0;
}

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

#include <iostream>
using namespace std;
int main() {
	//实现九九乘法表
	for (int i = 1; i <= 9; i++) {
		for (int j = 1; j <= i; j++) {
			cout << i << "x" << j <<"="<< i*j << "\t";
		}
		cout << endl;
	}
	system("pause");
	return 0;
}

4.3 跳转语句

4.3.1 break语句

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

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

4.3.2 continue语句

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

#include <iostream>
using namespace std;
int main() {
	for (int i = 0; i <= 100; i++) {
		if (i % 2 == 0) {
			continue;
		}
		cout << i << " ";
	}
	cout << endl;
	system("pause");
	return 0;
}

4.3.3 goto语句

作用：可以无条件跳转
语法：goto 标记
解释：如果标记的名称存在，执行到goto语句时，会跳转到标记的位置

 #include <iostream>
using namespace std;
int main() {
	//goto语句
	cout << "1.xxxxx" << endl;
	cout << "2.xxxxx" << endl;
	goto FLAG;
	cout << "3.xxxxx" << endl;
	FLAG:
    cout << "4.xxxxx" << endl;
	cout << "5.xxxxx" << endl;
	system("pause");
	return 0;
}

5 数组

5.1 概述

数组：存放了相同数据类型的数据元素的一个集合
特点1：数组中的每个数据元素都是相同的数据类型
特点2：数组是由连续的内存位置组成的
对于数组的下标，我们可以通过下标访问数组中的元素

5.2 一维数组

练习案例1：五只小猪称体重
案例描述：
在一个数组中记录了五只小猪的体重如：
int arr[5]={300,350,200,400,250};
找出并打印最重的小猪体重

#include <iostream>
using namespace std;
int main() {
	//五只小猪称体重
	//使用的是冒泡排序法
	//1.先用一个数组记录5只小猪的体重
	int arr[5] = {300,350,200,400,250};
	int temp = 0;
	int i = 0;
	//2.将小猪的体重显示在屏幕上
	cout << "五只小猪的体重分别是： ";
	while (i < 5) {
		cout << arr[i] << " ";
		i++;
	}
	cout << endl;
	for (int index = 0; index < 5; index++) {
	//3.比较5只小猪的体重，找出最重的
		for (int index1 = index + 1; index1 < 5; index1++) {
			if (arr[index] > arr[index1]) {
				temp = arr[index];
				arr[index] = arr[index1];
				arr[index1] = temp;
			}
		}
	}
	//4.打印输出最重的小猪体重
	cout << "最重的小猪体重为： " << arr[4] << endl;
	system("pause");
	return 0;
}

#include <iostream>
using namespace std;
int main() {
	//五只小猪称体重
	//1.先用一个数组记录5只小猪的体重
	int arr[5] = {300,350,200,400,250};
	//设置一个最重的体重为max
	int max = 0;
	int i = 0;
	//2.将小猪的体重显示在屏幕上
	cout << "五只小猪的体重分别是： ";
	while (i < 5) {
		cout << arr[i] << " ";
		i++;
	}
	cout << endl;
	for (int index = 0; index < 5; index++) {
	//3.比较5只小猪的体重，找出最重的
		if (arr[index] > max) {
			max = arr[index];
		}
	}
	//4.打印输出最重的小猪体重
	cout << "最重的小猪体重为： " << max << endl;
	system("pause");
	return 0;
}

练习案例2：数组元素逆置
案例描述：
请声明一个5个元素的数组，并且将元素逆置。
（如原数组元素为：1，3，2，5，4 逆置后结果为：4，5，2，3，1）；

#include <iostream>
using namespace std;
int main() {
	//数组元素逆置
	//1.声明一个5个元素的数组
	int arr[5];
	int index = 0;
	int temp = 0;
	//2.提示用户进行输入
	cout << "请输入5个整数： " << endl;
	while(index<5)
	{
		cin >> arr[index];
		index++;
	}
	//3.打印输出输入的数组元素
	cout << "您输入的数组元素为： ";
	for (int i = 0; i < 5; i++) {
		cout << arr[i] << " ";
	}
	cout << endl;
	//4.将数组的元素进行逆置
	for (int j = 0; j < 2; j++) {
		temp = arr[j];
		arr[j] = arr[4 - j];
		arr[4 - j] = temp;
	}
	//5.输出逆置后的数组元素
	cout << "逆置后的数组为： " << endl;
	for (int i = 0; i < 5; i++) {
		cout << arr[i] << " ";
	}
	cout << endl;
	system("pause");
	return 0;
}

#include <iostream>
using namespace std;
int main() {
	//数组元素逆置
	//1.声明一个5个元素的数组
	int arr[5] = {98,97,58,99,63};
	//2.打印输出逆置前的数组元素
	cout << "逆置前数组元素为： ";
	for (int i = 0; i < 5; i++) {
		cout << arr[i] << " ";
	}
	cout << endl;
	//3.将数组的元素进行逆置
	/*逆置的具体方法：原理就是前面和后面的元素位置互换
	1.先找到最前面的元素和最后一个元素的角标
	2.交换两元素的值，交换的时候不能忘记有中间变量temp
	（start++而对应的end--）
	3.直到前后两个角标相等时，停止交换
	*/
	int temp = 0;
	int start = 0;
	int end = sizeof(arr) / sizeof(arr[0]) - 1;
	while (!(start == end)) {
		temp = arr[start];
		arr[start] = arr[end];
		arr[end] = temp;
		start++;
		end--;
	}
	//4.输出逆置后的数组元素
	cout << "逆置后数组元素为： ";
	for (int i = 0; i < 5; i++) {
		cout << arr[i] << " ";
	}
	cout << endl;
	system("pause");
	return 0;
}

5.2.1 一维数组定义方式

三种定义数组的方法：

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

在这里插入图片描述

#include <iostream>
using namespace std;
int main() {
	//数组
	/*
	1. 数据类型 数组名[ 数组长度 ]；
	2. 数据类型 数组名[ 数组长度 ] = { 值1， 值2， ... }；
	3. 数据类型 数组名[] = { 值1， 值2， ... }；
	*/
	//1. 数据类型 数组名[数组长度]；
	int arr[5];
	arr[0] = 10;
	arr[1] = 20;
	arr[2] = 30;
	arr[3] = 40;
	arr[4] = 50;
	for (int index = 0; index < 5; index++) {
		cout << arr[index] << " ";
	}
	cout << endl;
	//2. 数据类型 数组名[数组长度] = { 值1， 值2， ... }；
	int arr[5] = { 10,20,30,40,50 };
	for (int index = 0; index < 5; index++) {
		cout << arr[index] << " ";
	}
	cout << endl;
//3. 数据类型 数组名[] = { 值1， 值2， ... }；
	int arr[] = { 10,20,30,40,50 };
	for (int index = 0; index < 5; index++) {
		cout << arr[index] << " ";
	}
	cout << endl;
	system("pause");
	return 0;
}

5.2.2 一维数组数组名

可以通过数组名统计整个数组在内存中的长度 sizeof( arr )
数组名是常量，不可以进行赋值操作
获取数组元素的地址可以使用(&arr[index])，其中index为索引
可以获取数组在内存中的首地址（arr)

int  arr[ 5 ] = {1,2,3,4,5};

在这里插入图片描述

#include <iostream>
using namespace std;
int main() {
	//数组名的用途
	//1.可以通过数组名统计数组所占的内存空间
	int arr[] = { 1,2,3,4,5 };
	cout << "arr数组所占内存空间为： " << sizeof(arr) << endl;
	//2.可以找到数组的地址
	cout << "arr数组的地址为： " << arr << endl;
	system("pause");
	return 0;
}

在这里插入图片描述 对于数组的角标（索引）可以利用sizeof来表示：

start索引值为0
数组长度：sizeof(arr) / sizeof(arr[0])
end索引值：sizeof(arr) / sizeof(arr[0])-1

5.2.3 冒泡排序

比较相邻的两个元素，如果第一个比第二个大就交换
对每一对相邻元素做同样的工作，执行完毕后，找到第一个最大值
重复以上的步骤，每次比较次数减一，直到不需要比较

#include <iostream>
using namespace std;
int main() {
	//将数组（4，2，8，0，5，7，1，3，9）进行升序排序
	int arr[] = {4,2,8,0,5,7,1,3,9};
	//定义中间变量temp暂存数组元素的值
	int temp = 0;
	//1.输出排序前的数组
	cout << "排序前数组为： " << endl;
	for (int i = 0; i < (sizeof(arr) / sizeof(arr[0])); i++) {
		cout << arr[i] << " ";
	}
	cout << endl;
	//2.将数组元素进行比较交换位置排序
	for (int i = 0; i < (sizeof(arr) / sizeof(arr[0])); i++) {
		for (int j = i+1; j < (sizeof(arr) / sizeof(arr[0])); j++) {
			if (arr[i] > arr[j]) {
				temp = arr[i];
				arr[i] = arr[j];
				arr[j] = temp;
			}
		}
	}
	//3.输出排序后的数组
	cout << "排序后数组为： " << endl;
	for (int i = 0; i < (sizeof(arr) / sizeof(arr[0])); i++) {
		cout << arr[i] << " ";
	}
	cout << endl;
	system("pause");
	return 0;
}

//2.将数组元素进行比较交换位置排序
for (int i = 0; i < (sizeof(arr) / sizeof(arr[0])-1); i++) //比较的次数，9个数比较8次{
	for (int j = 0; j < (sizeof(arr) / sizeof(arr[0]))-1-i; j++) {
		if (arr[j] > arr[j+1]) {
			temp = arr[j];
			arr[j] = arr[j+1];
			arr[j+1] = temp;
		}
	}
}

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][2];
	arr[0][0] = 1;
	arr[0][1] = 2;
	arr[1][0] = 3;
	arr[1][1] = 4;
	//输出数组值
	for (int i = 0; i < 2; i++) {
		for (int j = 0; j < 2; j++) {
			cout << arr[i][j] << " ";
		}
	}
	cout << endl;
	system("pause");
	return 0;
}

方式二

#include <iostream>
using namespace std;
int main() {
	//方式2
	//数组类型 数组名[行数][列数] = { { 数据1，数据2} ，{数据3 ， 数据4} }；
	int arr[2][2] = { {1,2} ,{3,4} };
	//输出数组值
	for (int i = 0; i < 2; i++) {
		for (int j = 0; j < 2; j++) {
			cout << arr[i][j] << " ";
		}
	}
	cout << endl;
	system("pause");
	return 0;
}

方式三

#include <iostream>
using namespace std;
int main() {
	//方式3
	//数组类型 数组名[行数][列数] = { 数据1，数据2，数据3 ，数据4}；
	int arr[2][2] = { 1,2,3,4 };
	//输出数组值
	for (int i = 0; i < 2; i++) {
		for (int j = 0; j < 2; j++) {
			cout << arr[i][j] << " ";
		}
	}
	cout << endl;
	system("pause");
	return 0;
}

方式四

#include <iostream>
using namespace std;
int main() {
	//方式4
	//数组类型 数组名[][列数] = { 数据1，数据2，数据3 ，数据4}；
	int arr[][2] = { 1,2,3,4 };
	//输出数组值
	for (int i = 0; i < 2; i++) {
		for (int j = 0; j < 2; j++) {
			cout << arr[i][j] << " ";
		}
	}
	cout << endl;
	system("pause");
	return 0;
}

5.3.2 二维数组数组名

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

 #include <iostream>
using namespace std;
int main() {
	//二维数组数组名
	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 << "二维数组首地址： " << &arr[0][0] << endl;
	system("pause");
	return 0;
}

5.3.3 二维数组应用案例

考试成绩统计：

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

科目/姓名	语文	数学	英语
张三	100	100	100
李四	90	50	100
王五	60	70	80

#include <iostream>
using namespace std;
int main() {
	int score[3][3] = {
		{100,100,100},
		{90,50,100},
		{60,70,80}
	};
	cout << "张三的总成绩为： " << score[0][0]+ score[0][1]+score[0][2] << endl;
	cout << "李四的总成绩为： " << score[1][0] + score[1][1] + score[1][2] << endl;
	cout << "王五的总成绩为： " << score[2][0] + score[2][1] + score[2][2] << endl;
	system("pause");
	return 0;
}

#include <iostream>
using namespace std;
int main() {
	int score[3][3] = {
		{100,100,100},
		{90,50,100},
		{60,70,80}
	};
	for (int i = 0; i < 3; i++) {
		int sum = 0;
		//计算单个人的总成绩
		for (int j = 0; j < 3 ; j++) {
			sum += score[i][j];
		}
		switch (i) {
		case 0: cout << "张三的总成绩为： " << sum << endl; break;
		case 1: cout << "李四的总成绩为： " << sum << endl; break;
		case 2: cout << "王五的总成绩为： " << sum << endl; break;
		}
	}
	system("pause");
	return 0;
}

6 函数

6.1 概述

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

6.2 函数的定义

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

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

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

return表达式
}

例如：实现一个加法的函数
功能是：传入两个整型数据，计算数据相加的结果，并且返回。

#include <iostream>
using namespace std;
int sum(int a, int b);//函数的声明
//函数定义在调用之后要进行声明，在之前则可以直接调用
int main() {
	int value = 0;
	int num1 = 0;
	int num2 = 0;
	cout << "请输入第一个数的值：" << endl;
	cin >> num1;
	cout << "请输入第二个数的值：" << endl;
	cin >> num2;
	value = sum(num1, num2);
	cout << num1 << "和" << num2 << "的和是" << value << endl;
	system("pause");
	return 0;
}
int sum(int a, int b) {
	int sum = a + b;
	return sum;
}

6.3 函数的调用

功能：使用定义好的函数
语法：函数名（参数）

6.4 值传递

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

 #include <iostream>
using namespace std;
void swap(int, int);
int main() {
	int a = 1;
	int b = 2;
	//调用交换函数
	swap(a, b);
	cout << "a的值为： " << a << " ";
	cout << "b的值为： " << b << endl;
	system("pause");
	return 0;
}
//定义交换函数
void swap(int num1, int num2) {
	cout << "交换前： " << endl;
	cout << "num1的值： " << num1 << " ";
	cout << "num2的值： " << num2 << endl;

	int temp = num1;
	num1 = num2;
	num2 = temp;

	cout << "交换后： " << endl;
	cout << "num1的值： " << num1 << " ";
	cout << "num2的值： " << num2 << endl;
}

6.5 函数的常见样式

无参无返
有参无返
无参有返
有参有返
示例：

#include <iostream>
using namespace std;

//函数常见样式
//1.无参无返
void test1() {
	cout << "你好好看！" << endl;
}
//2.有参无返
void test2(int a,int b) {
	//交换a,b的值
	int temp = a; 
	a = b;
	b = temp;
}
//3.无参有返
int test3() {
	int arr[3] = { 1,2,3 };
	return arr[0];
}
//4.有参有返
int test4(int a, int b) {
	int sum = a + b;
	return sum;
}
int main() {
	system("pause");
	return 0;
}

6.6 函数的声明

作用：告诉编译器函数名称及如何调用函数，函数的实际主体可以单独定义
函数的声明可以多次，但是函数的定义只能有一次

#include <iostream>
using namespace std;
//声明可以多次，但是定义只有一次
//声明
int max(int a, int b);
int max(int a, int b);
//定义
int max(int a, int b) {
	return a > b ? a : b;
}
int main() {
	//调用函数max()
	int result = max(6, 8);
	cout << "较大值为：" << result << endl;
	system("pause");
	return 0;
}

6.7 函数的分文件编写

作用：让代码结构更加清晰
函数分文件编写一般有4个步骤

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

//swap.h文件
#include <iostream>
using namespace std;
//.h文件里是函数的声明

//实现两个数字交换的函数声明
void swap(int a, int b);

//swap.cpp文件
#include "swap.h"
#include <iostream>
using namespace std;
//swap函数定义
void swap(int a, int b) {
	int temp = a;
	a = b;
	b = temp;
}

7 指针

7.1 指针的基本概念

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

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

7.2 指针变量的定义和使用

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

#include <iostream>
using namespace std;
int main() {
	//1.定义指针变量
	int a = 0;//定义整型变量
	int *b;
	b = &a;//定义指针变量b为a的地址
	cout << "b的值为: " << b << endl;
	system("pause");
	return 0;
}

7.3 指针所占内存空间

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

在32位操作系统下：占用4个字节空间，64位下占8个字节

#include <iostream>
using namespace std;
int main() {
	//1.定义指针变量
	int a = 0;//定义整型变量
	int *b;
	b = &a;//定义指针变量b为a的地址
	cout << *b << endl;//解引用，b指向地址所保存的值
	cout << sizeof(b) << endl;
	cout << sizeof(int *) << endl;
	cout << sizeof(char *) << endl;
	cout << sizeof(float *) << endl;
	cout << sizeof(double *) << endl;
	system("pause");
	return 0;
}

7.4 空指针和野指针

空指针：指针变量指向内存中编号为0的空间
用途：初始化指针变量
注意：空指针指向的内存是不可以访问的
示例1：空指针

#include <iostream>
using namespace std;
int main() {
	//指针变量p指向内存中编号为0的空间
	int *p = NULL;
	//访问空指针报错
	//内存编号0~255为系统占用内存，不允许用户访问
	cout << *p << endl;
	system("pause");
	return 0;
}

野指针：指针变量指向非法的（不是用户申请的）内存空间
示例2：野指针

#include <iostream>
using namespace std;
int main() {
	//指针变量p指向内存中编号为0x1100的空间
	int *p = (int *)0x1100;
	//访问野指针报错
	cout << *p << endl;
	system("pause");
	return 0;
}

7.5 const修饰指针

const修饰的指针有三种情况：

const修饰指针 ——常量指针
const修饰常量 ——指针常量
const即修饰指针，又修饰常量

#include <iostream>
using namespace std;
int main() {
	int a = 0;
	// const修饰指针,指针指向可以改，但是指向的值不可以改
	const int *p = 0;
	//*p = 1;//错误
	p = &a;
	//const修饰常量，指针指向不可以改，但指向的值可以改
    int  * const q = 0;
	//q=&a;//错误
	*q = 9;
	system("pause");
	return 0;
}

7.6 指针和数组

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

#include <iostream>
using namespace std;
int main() {
	int arr[] = { 1,2,3,4,5,6 };
	int *p = arr;//定义p指针指向数组
	cout << "第一个元素： " << arr[0] << endl;
	cout << "指针访问第一个元素： " << *p << endl;
	//利用指针遍历数组
	for(int i = 0; i < sizeof(arr) / sizeof(arr[0]); i++) {
		cout << *p << " ";
		p++;
	}
	cout << endl;
	system("pause");
	return 0;
}

7.7 指针和函数

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

#include <iostream>
using namespace std;
//实现两个数字进行交换
void swap1(int a, int b) {
	int temp = a;
	a = b;
	b = temp;
	cout << "swap1 a,b的值分别为： " << a << " " << b << endl;
}
void swap2(int *p, int *q) {
	int temp = *p;
	*p = *q;
	*q = temp;
	cout << "swap2 a,b的值分别为： " << *p << " " << *q << endl;
}
int main() {
	//指针和函数
	//1.值传递
	int a = 10;
	int b = 20;
	swap1(a, b);
	cout << "交换后a,b的值分别为： " << a << " " << b << endl;
	//2.指针传递
	swap2(&a, &b);
	cout << "交换后a,b的值分别为： " << a << " " << b << endl;
	system("pause");
	return 0;
}

在这里插入图片描述

7.8 指针、数组、函数

案例描述： 封装一个函数，利用冒泡排序，实现对整型数组的升序排序
例如数组：int arr[ 10 ] = { 4,3,6,9,1,2,10,8,7,5 }

#include <iostream>
using namespace std;
//冒泡排序
void bubbleSort(int * arr,int length ) {//定义了一个指向数组的指针，传实参时就传地址
	for (int i = 0; i < length-1; i++) {
		for (int j = 0; j < length - 1 - i; j++) {
			if (arr[j] > arr[j + 1]) {
				int temp = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = temp;
			}
		}
	}
}
int main() {
	int arr[10] = { 4,3,6,9,1,2,10,8,7,5 };
	cout << "调用bubbleSort函数前的数组元素： " << endl;
	for (int i = 0; i < 10; i++) {
		cout << arr[i] << " ";
	}
	cout << endl;
	bubbleSort(&arr[0], 10);
	cout << "调用bubbleSort函数后的数组元素： " << endl;
	for (int i = 0; i < 10; 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>
//1.创建学生数据类型：学生包括（姓名、年龄、分数）
struct student {
	//成员列表
	//姓名
	string name;
	//年龄
	int age;
	//分数
	int score;
}s3;//2.3 在定义结构体的时候创建变量
int main() {
	//2.通过学生类型创建具体学生
	//2.1 struct student s1
	struct student s1;
	s1.name = "李华";
	s1.age = 18;
	s1.score = 99;
	cout << s1.name << "的年龄是： " << s1.age << ", " << "分数是： " << s1.score << endl;
	//2.2 struct student s2{ ... }
	struct student s2 { "韩梅梅", 20, 89 };
	cout << s2.name << "的年龄是： " << s2.age << ", " << "分数是： " << s2.score << endl;
	s3.name = "王五";
	s3.age = 22;
	s3.score = 87;
	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 arr[3] = 
	{
		{ "张三", 20, 89 },
		{ "李四", 22, 90 },
		{ "王二", 24, 91 }
	};
	for (int i = 0; i < 3; i++) {
		cout << arr[i].name << "的年龄是： " << arr[i].age << ", " << "分数是： " << arr[i].score << endl;
	}
	system("pause");
	return 0;
}

8.4 结构体指针

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

#include <iostream>
using namespace std;
#include <string>
//结构体指针
struct student {
	//成员列表
	string name;	//姓名
    int age;	//年龄
	int score;	//分数
};
int main() {
	//创建学生结构体变量
	struct student s = { "张三", 20, 89 };
	//通过指针指向结构体变量
	struct student * p = &s;
	//通过指针访问结构体变量中的数据
	cout << "姓名：" << p->name << 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() {
	//结构体嵌套结构体
	//创建老师结构体变量
	struct student stu = { "张三", 20, 89 };
	struct teacher tea;
	struct student *p = &stu;
	tea.id = 15;
	tea.name = "lili";
	tea.age = 58;
	tea.stu.age = p->age;
	tea.stu.name = p->name;
	tea.stu.score = p->score;
	cout << tea.name << "的年龄是： " << tea.age << ", " << "学生的分数是： " << tea.stu.score << endl;
	system("pause");
	return 0;
}

8.6 结构体做函数参数

作用： 将结构体作为函数参数向函数中传递
传递方式有两种： 1.值传递 2.地址传递

#include <iostream>
using namespace std;
#include <string>
//学生结构体定义
struct student {
	//成员列表
	string name;	//姓名
    int age;	//年龄
	int score;	//分数
};
//1.值传递
void printStuname(student stu) {
	cout <<"值传递时： "<< stu.name << "的年龄是： " << stu.age << ", " << "分数是： " << stu.score << endl;
}
//2.地址传递
void printStuname1(student *stu) {
	cout << "地址传递时： " << stu->name << "的年龄是： " << stu->age << ", " << "分数是： " << stu->score << endl;
}
int main() {
	student a = { "张三", 20, 89 };
	printStuname(a);
	printStuname1(&a);
	system("pause");
	return 0;
}

8.7 结构体中const使用场景

作用： 用const来防止误操作
示例：

#include <iostream>
using namespace std;
#include <string>
//学生结构体定义
struct student {
	//成员列表
	string name;	//姓名
    int age;	//年龄
	int score;	//分数
};
//const使用场景
void printStuname1(student const *stu) {//用const来防止误操作
	//stu->age = 98;//操作失败，因为加了const修饰
	cout << "地址传递时： " << stu->name << "的年龄是： " << stu->age << ", " << "分数是： " << stu->score << endl;
}
int main() {
	student a = { "张三", 20, 89 };
	printStuname1(&a);
	system("pause");
	return 0;
}

8.8 结构体案例

8.8.1 案例1

案例描述：
学校正在做毕设项目，每名老师带领5个学生，总共有三名老师，需求如下：

设计学生和老师的结构体，其中在老师的结构体中，有老师姓名和一个存放5名学生的数组作为成员
学生的成员有姓名、考试分数、创建数组存放三名老师，通过函数给每个老师及所需的学生赋值
最终打印输出老师数据以及老师所需的学生数据
示例：

#include <iostream>
using namespace std;
#include <string>
#include <ctime>
//学生结构体定义
struct student {
	string sname;//姓名
	int score;//考试分数
};
//老师结构体定义
struct teacher {
	string tname;//老师姓名
	struct student sarr[5];
};
//给三位老师赋值的函数
void allocateSpace(struct teacher teach[], int length) {
	//给老师赋值
	srand((unsigned int)time(NULL));//以系统时间为随机来设置
	string nameSeed = "ABCDE";
	for (int i = 0; i < length; i++) {
		teach[i].tname = "teacher_";
		teach[i].tname += nameSeed[i];
		//给学生赋值
		for (int j = 0; j < 5; j++) {
			teach[i].sarr[j].sname = "student_";
			teach[i].sarr[j].sname += nameSeed[j];
			teach[i].sarr[j].score = rand() % 40 + 60;//0~39之间的随机数+60
		}
	}
}
//打印信息
void printinfo(struct teacher teach[], int length) {
	for (int i = 0; i < length; i++) {
		cout << teach[i].tname << "的五个学生是： " << endl;
		for (int j = 0; j < 5; j++) {
			cout << teach[i].sarr[j].sname << " ";
			cout << "分数是： " << teach[i].sarr[j].score << endl;
		}
	}
}
int main() {
	//创建3名老师的数组
	struct teacher teach[3];
	//通过函数给3名老师赋值并老师所带的学生赋值
	int length = sizeof(teach) / sizeof(teach[0]);
	allocateSpace(teach, length);
	printinfo(teach,length);
	system("pause");
	return 0;
}

8.8.2 案例2

案例描述：

设计一个英雄的结构体，包括成员姓名、年龄、性别；
创建结构体数组，数组中存放5名英雄
通过冒泡排序的算法，将数组中的英雄按年龄进行升序排序，最终打印排序后的结果
五名英雄信息如下：

{“刘备”，23，“男”}，
{“关羽”，22，“男”}，
{“张飞”，20，“男”}，
{“赵云”，21，“男”}，
{“貂蝉”，19，“女”}，

#include <iostream>
#include <string>
using namespace std;
//创建一个英雄的结构体
struct hero {
	string name;//姓名
	int age;//年龄
	string sex;//性别
};
//冒泡排序函数
void bubblesort(struct hero SG[], int len) {
	for (int i = 0; i < len; i++) {
		//冒泡排序前的年龄
		cout << SG[i].name << "的年龄是： " << SG[i].age << endl;
		for (int j = 0; j < len - 1 - i; j++) {
			if (SG[j].age > SG[j + 1].age) {
				int temp = SG[j].age;
				SG[j].age = SG[j + 1].age;
				SG[j + 1].age = temp;
			}
		}
	}
}
int main() {
	//创建结构体数组，数组中存放5名英雄
	struct hero SG[5] =
	{
		{ "刘备",23,"男" },
		{ "关羽",22,"男" },
		{ "张飞",20,"男" },
		{ "赵云",21,"男" },
		{ "貂蝉",19,"女" },
	};
	//调用冒泡排序函数，将数组中的英雄按年龄进行升序排序
	int len = sizeof(SG) / sizeof(SG[0]);
	bubblesort(&SG[0],len );
	//打印排序后的结果
	cout << "升序排序后的年龄是： " << endl;
	for (int i = 0; i < len ; i++) {
		cout << SG[i].age << " ";
	}
	cout << endl;
	system("pause");
	return 0;
}