黑马C++ 01 基础2 —— 数组、函数

2021 Nqq

已于 2022-11-21 21:48:12 修改

阅读量372

点赞数

分类专栏： B站系统学习C++ 文章标签： c++ 算法

于 2022-08-11 14:40:38 首次发布

本文链接：https://blog.csdn.net/qq_42731062/article/details/126277641

版权

B站系统学习C++ 专栏收录该内容

22 篇文章 5 订阅

订阅专栏

文章目录

1 一维数组
2 二维数组
3 函数

1 一维数组

1.1 一维数组定义

在这里插入图片描述
一维数组定义的三种方式：

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

#include<iostream>
using namespace std;

int main()
{
	// 定义方式1
	// 数据类型 数组名[元素个数];
	int score[10];

	// 利用下标赋值,从0开始索引
	score[0] = 100;
	score[1] = 99;
	score[2] = 85;

	// 利用下标输出
	cout << score[0] << endl;
	cout << score[1] << endl;
	cout << score[2] << endl;

	// 第二种定义方式
	// 数据类型 数组名[元素个数] =  {值1，值2 ，值3 ...};
	// 如果{}内不足10个数据，剩余数据用0补全
	int score2[10] = { 100,90,80,70,60,50,40,30,20,10 };

	// 逐个输出
	// cout << score2[0] << endl;
	// cout << score2[1] << endl;

	// 一个一个输出太麻烦，因此可以利用循环进行输出
	for (int i = 0; i < 10; i++)
	{
		cout << score2[i] << endl;
	}

	// 定义方式3
	// 数据类型 数组名[] =  {值1，值2 ，值3 ...};
	int score3[] = { 100,90,80,70,60,50,40,30,20,10 };
	for (int i = 0; i < 10; i++)
	{
		cout << score3[i] << endl;
	}

	system("pause");
	return 0;
}

1.2 一维数组数组名(重点)

在这里插入图片描述

一维数组名称的用途：

统计整个数组在内存中的长度：sizeof(arr)
获取数组在内存中的首地址，这里的地址指的是字节的地址：arr数组名就是数组的首地址

程序如下

可获取整个数组占用的空间，sizeof(arr)，整型是4个字节大小

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;

结果
可通过数组名称查看数组在内存中的首地址,cout << arr << endl
数组名就是数组的首地址

cout << "数组首地址为：" << (int)arr << endl;// 10进制地址
cout << "数组首地址为：" << arr << endl;// 16进制地址
cout << "数组第一个元素地址为：" << (int)&arr[0] << endl;
cout << "数组第二个元素地址为：" << (int)&arr[1] << endl;//整型是四个字节

结果

总结
注意：数组名是常量，不可以赋值
总结1：直接打印数组名，可以查看数组所占内存的首地址
总结2：对数组名进行sizeof，可以获取整个数组占内存空间的大小

1.3 一维数组练习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 };

	// 2.从数组中找最大值
	int max = 0;

	// 访问数组中的每个元素，如果这个元素比我认定的最大值大，更新最大值
	for (int i = 0; i < 5; i++)
	{
		if (arr[i] > max)
		{
			max = arr[i];
		}
	}

	// 3.打印最大值
	cout << "最重的小猪体重：" << max;
}

1.4 一维数组练习2：数组元素逆置

案例描述：请声明一个5个元素的数组，并且将元素逆置(如原数组元素为：1,3,2,5,4;逆置后输出结果为:4,5,2,3,1)。

分析

#include<iostream>
using namespace std;

int main()
{
	// 请声明一个5个元素的数组，并且将元素逆置
	// 如原数组元素为：1, 3, 2, 5, 4; 逆置后输出结果为:4, 5, 2, 3, 1

	// 1.创建数组
	int arr[5] = { 1,3,2,5,4 };
	cout << "数组元素逆置前：" << endl;
	for (int i = 0; i < 5; i++)
	{
		cout << arr[i] << endl;
	}

	// 2.实现逆置
	// 2.1记录起始下标的位置
	// 2.2记录结束下标的位置
	// 2.3起始下标与结束下标的元素互换
	// 2.4起始位置++ 结束位置--
	// 2.5循环执行2.1的操作，直到起始位置>=结束位置
	int start = 0;// 2.1 起始下标
	int end = sizeof(arr) / sizeof(arr[0]) - 1;// 2.2 结束下标

	while (start < end)// 2.5 循环条件
	{
		// 2.3 元素互换
		int temp = arr[0];
		arr[start] = arr[end];
		arr[end] = temp;

		// 2.4 下标更新
		start++;
		end--;
	}

	// 3.打印逆置后的数组
	cout << "数组元素逆置后：" << endl;
	for (int i = 0; i < 5; i++)
	{
		cout << arr[i] << endl;
	}

	system("pause");
	return 0;
}

1.5 冒泡排序

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

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

示例： 将数组 { 4,2,8,0,5,7,1,3,9 } 进行升序排序
在这里插入图片描述

分析
排序总轮数 = 元素个数 - 1（i的范围）
每轮对比次数 = 元素个数 - 排序轮数 - 1（j的范围）

#include<iostream>
using namespace std;

int main()
{
	//1.比较相邻的元素。如果第一个比第二个大，就交换他们两个。
	//2.对每一对相邻元素做同样的工作，执行完毕后，找到第一个最大值。
	//3.重复以上的步骤，每次比较次数 - 1，直到不需要比较
	//9个元素第一轮做8次交换，找到第1个最大数，第二轮做7次交换，找到第2个最大数

	//1.利用冒泡排序实现升序排列
	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;

	//2.冒泡排序 
	//排序的总轮数 = 元素个数 - 1
	int temp;
	for (int i = 0; i < 9 - 1; i++) //外侧排序的轮数
	{
		//内层的循环对比 每轮对比的次数 = 元素个数 - 排序轮数(第几轮，从0开始算起) - 1
		for (int j = 0; j < 9 - i - 1; j++)
		{
			//如果第一个数字，比第二个数字大，就交换这两个数字
			if (arr[j] > arr[j + 1])
			{
				// int temp = arr[j];// temp 要进行赋值
				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;
}

结果

2 二维数组

2.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 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] << " ";
		}
		cout << endl;
	}

	//方式2 
	//数据类型 数组名[行数][列数] = { {数据1，数据2 } ，{数据3，数据4 } };
	int arr2[2][3] =
	{
		{1,2,3},
		{4,5,6}
	};

	//方式3
	//数据类型 数组名[行数][列数] = { 数据1，数据2 ,数据3，数据4  };
	int arr3[2][3] = { 1,2,3,4,5,6 };

	//方式4 
	//数据类型 数组名[][列数] = { 数据1，数据2 ,数据3，数据4  };
	int arr4[][3] = { 1,2,3,4,5,6 };

	system("pause");
	return 0;
}

2.2 二维数组数组名

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

#include<iostream>
using namespace std;

int main()
{
	// 二维数组名称用途
	// 1.可以查看占用内存空间大小
	int arr[2][3] =
	{
		{1,2,3},
		{4,5,6}
	};

	cout << "二维数组占用内存空间大小： " << sizeof(arr) << endl;// 24 = 4 * 6
	cout << "二维数组第一行占用内存大小： " << sizeof(arr[0]) << endl;// 12 
	cout << "二维数组第一个元素占用内存大小： " << sizeof(arr[0][0]) << endl;// 4

	cout << "二维数组行数： " << sizeof(arr) / sizeof(arr[0]) << endl;// 2
	cout << "二维数组列数： " << sizeof(arr[0]) / sizeof(arr[0][0]) << endl;// 3

	// 2. 可以查看二维数组的首地址
	cout << "二维数组首地址：" << (int)arr << endl;
	cout << "二维数组第一行首地址：" << (int)arr[0] << endl;
	cout << "二维数组第二行首地址：" << (int)arr[1] << endl;

	cout << "二维数组第一个元素地址：" << (int)&arr[0][0] << endl;
	cout << "二维数组第二个元素地址：" << (int)&arr[0][1] << endl;

	system("pause");
	return 0;
}

结果
总结
1：二维数组名就是这个数组的首地址
2：对二维数组名进行sizeof时，可以获取整个二维数组占用的内存空间大小

2.3 二维数组练习：考试成绩统计

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

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

分析

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

int main()
{
	//二维数组案例—考试成绩统计

	//1.创建二维数组
	int score[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 += score[i][j];
		}
		cout << name[i] << "同学总成绩为： " << sum << endl;
	}

	system("pause");
	return 0;
}

结果

3 函数

3.1 函数定义

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

       return表达式
}

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

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

//函数定义
int add(int num1, int num2)
{
	int sum = num1 + num2;
	return sum;
}

3.2 函数调用

函数名（参数）
函数定义里小括号内称为形参，函数调用时传入的参数称为实参

#include<iostream>
using namespace std;

// 函数的定义
// 返回值类型 函数名(参数列表) {函数体语句 return表达式}

// 加法函数，实现两个整数相加，并且返回相加的结果
// 函数定义时，num1和num2并没有真实的数据，只是形式上参数，简称形参
int add(int num1, int num2)// 返回的是整型
{
	int sum = num1 + num2;
	return sum;
}

int main()
{
	int a = 10;
	int b = 20;
	// 函数调用语法：函数名称(参数)
	// a和b是实际的参数，简称实参
	// 调用函数时，实参的值会传递给形参
	int c = add(a, b);
	cout << "c=" << c << endl;
	system("pause");
	return 0;
}

3.3 值传递(形参无法修改实参)

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

#include<iostream>
using namespace std;

//值传递（形参变化之后不会改变实参）
//地址传递——形参改变，实参也会改变
//定义函数，实现两个数字进行交换函数

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

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

	cout << "交换后：" << endl;
	cout << "num1 = " << num1 << endl;
	cout << "num2 = " << num2 << endl;
	//return；返回值不需要时可以不写return
}
int main()
{
	int a = 10;
	int b = 20;

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

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

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

	system("pause");
	return 0;
}

结果

3.4 函数的常见样式

常见的函数样式有4种

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

#include<iostream>
using namespace std;

//函数常见样式
//1、 无参无返
void test01()
{
	//void a = 10; //无类型不可以创建变量,原因无法分配内存
	cout << "this is test01" << endl;
	//test01(); 函数调用
}

//2、 有参无返
void test02(int a)
{
	cout << "this is test02" << endl;
	cout << "a = " << a << endl;
}

//3、无参有返
int test03()
{
	cout << "this is test03 " << endl;
	return 10;
}

//4、有参有返
int test04(int a, int b)
{
	cout << "this is test04 " << endl;
	int sum = a + b;
	return sum;
}

int main()
{
	//无参无返函数调用
	test01();

	//有参无返函数调用
	test02(10);

	//无参有返函数调用
	int num1 = test03();
	cout << "num1 = " << num1 << endl;//num1 = 10

	//有参有返函数调用
	int num2 = test04(10, 20);
	cout << "num2 = " << num2 << endl;

	system("pause");
	return 0;
}

3.5 函数声明

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

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

#include<iostream>
using namespace std;

// 函数的声明
// 比较函数，实现两个整型数字进行比较，返回较大的值

// 提前告诉编译器函数的存在，可以利用函数的声明(如果函数定义在main函数后面)
// 声明可以写多次，定义只能有一次

// 函数的声明(函数往后写，告诉编译器函数存在)
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()
{
	int a = 10;
	int b = 20;

	cout << max(a, b) << endl;

	system("pause");
	return 0;
}

3.6 函数分文件编写

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

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

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

程序如下

头文件 swap.h

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

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

源文件 swap.cpp

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

void swap(int a, int b)
{
	int temp = a;
	a = b;
	b = temp;

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

源文件 main.cpp

#include<iostream>
using namespace std;
#include"swap.h" //这样就可以直接在main函数中使用swap函数

//函数的分文件编写
//实现两个数字交换的函数

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

//函数的定义
//void swap(int a, int b)
//{
//	int temp = a;
//	a = b;
//	b = temp;
//
//	cout << "a=" << a << endl;
//	cout << "b=" << b << endl;
//}

//一般来说这里只要写main函数
int main()
{
	int a = 10;
	int b = 20;

	swap(a, b);

	system("pause");
	return 0;
}