C++系列内容的学习目录 → \rightarrow →C++学习系列内容汇总。
1. 数组概述
所谓数组，就是一个集合，里面存放了相同类型的数据元素。
数组的特点：
- 数组中的每个数据元素都是相同的数据类型；
- 数组是由连续的内存位置组成的。
C++ 支持数组数据结构，它可以存储一个固定大小的相同类型元素的顺序集合。数组是用来存储一系列数据，但它往往被认为是一系列相同类型的变量。
数组的声明并不是声明一个个单独的变量，比如 number0、number1、…、number99，而是声明一个数组变量，比如 numbers，然后使用 numbers[0]、numbers[1]、…、numbers[99] 来代表一个个单独的变量。数组中的特定元素可以通过索引访问。
所有的数组都是由连续的内存位置组成。最低的地址对应第一个元素，最高的地址对应最后一个元素。
2. 一维数组
2.1 一维数组定义方式
一维数组定义的三种方式：
数据类型 数组名[ 数组长度 ];数据类型 数组名[ 数组长度 ] = { 值1，值2 ...};数据类型 数组名[ ] = { 值1，值2 ...};
一维数组的第一种定义方式数据类型 数组名[ 数组长度 ];的实例如下所示。
#include<iostream>
using namespace std;
int main()
{
//数组
/*
1.数据类型 数组名[数组长度];
2.数据类型 数组名[数组长度] = { 值1，值2 ... };
3.数据类型 数组名[] = { 值1，值2 ... };
*/
//1.数据类型 数组名[数组长度];
int arr1[3];
//给数组中的元素进行赋值
arr1[0] = 10; //数组中的元素是从0开始索引的
arr1[1] = 20;
arr1[2] = 30;
//访问数据元素
cout << arr1[0] << endl;
cout << arr1[1] << endl;
cout << arr1[2] << endl;
system("pause");
return 0;
}
10
20
30
一维数组的第二种定义方式数据类型 数组名[ 数组长度 ] = { 值1，值2 ...};的实例如下所示。
#include<iostream>
using namespace std;
int main()
{
//数组
/*
1.数据类型 数组名[数组长度];
2.数据类型 数组名[数组长度] = { 值1，值2 ... };
3.数据类型 数组名[] = { 值1，值2 ... };
*/
//2.数据类型 数组名[数组长度] = { 值1，值2 ... };
//如果在初始化数据时，没有全部填写完，会用0来填补剩余数据
int arr2[3] = { 40, 50, 60 };
//cout << arr2[0] << endl;
//cout << arr2[1] << endl;
//cout << arr2[2] << endl;
//利用循环来输出数组中的元素
for (int i = 0; i < 3; i++)
{
cout << arr2[i] << endl;
}
system("pause");
return 0;
}
40
50
60
一维数组的第三种定义方式数据类型 数组名[] = { 值1，值2 ... };的实例如下所示。
#include<iostream>
using namespace std;
int main()
{
//数组
/*
1.数据类型 数组名[数组长度];
2.数据类型 数组名[数组长度] = { 值1，值2 ... };
3.数据类型 数组名[] = { 值1，值2 ... };
*/
//3.数据类型 数组名[] = { 值1，值2 ... };
//定义数组的时候，必须有初始长度
int arr3[] = { 70, 80, 90 };
for (int i = 0; i < 3; i++)
{
cout << arr3[i] << endl;
}
system("pause");
return 0;
}
70
80
90
总结： 1. 数组名的命名规范与变量名命名规范一致，不要和变量重名；
2. 数组中下标是从0开始索引。
2.2 一维数组数组名
一维数组名称的用途：
- 可以统计整个数组在内存中的长度；
- 可以获取数组在内存中的首地址。
要注意的是， 数组名是常量，不可以赋值。
实例如下所示。
#include<iostream>
using namespace std;
int main()
{
//数组名用途
//1.可以通过数组名统计整个数组占用的内存大小
int arr[10] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
cout << "整个数组占用的内存空间为：" << sizeof(arr) << endl;
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;
}
整个数组占用的内存空间为：40
每个元素占用的内存空间为：4
整个数组中元素个数为：10
数组首地址为：7797316
数组中第一个元素的地址为：7797316
数组中第二个元素的地址为：7797320
总结： 1. 直接打印数组名，可以查看数组所占内存的首地址；
2. 对数组名进行sizeof，可以获取整个数组占内存空间的大小。
练习案例1：五只小猪称体重。
案例描述： 在一个数组中记录了五只小猪的体重，如：int arr[5] = {300,350,200,400,250}; 找出并打印最重的小猪体重。
编程思路： 先假定最大值为0，访问数组中的每个元素，如果这个元素比之前认定的最大值大，更新最大值。
练习案例的代码如下所示。
#include<iostream>
using namespace std;
int main()
{
//1. 创建5只小猪体重的数组
int arr[5] = { 300, 350, 200, 400, 250 };
//2. 从数组中找到最大值
int max = 0; // 先假定一个最大值为0
for (int i = 0; i < 5; i++)
{
if (arr[i] > max)
{
max = arr[i];
}
}
//3.打印最终的小猪体重
cout << "最重的小猪体重为：" << max << endl;
system("pause");
return 0;
}
最重的小猪体重为：400
练习案例2： 数组元素逆置。
案例描述： 请声明一个5个元素的数组，并且将元素逆置。(如原数组元素为：1,3,2,5,4；逆置后输出结果为：4,5,2,3,1)
练习案例的代码如下所示。
#include<iostream>
using namespace std;
int main()
{
//实现数组元素逆置
//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; //起始下标
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;
}
数组逆置前：
1
3
2
5
4
数组元素逆置后为：
4
5
2
3
1
2.3 冒泡排序
冒泡排序的作用： 最常用的排序算法，对数组内元素进行排序。
练习案例： 将数组 { 4,2,8,0,5,7,1,3,6,9 } 进行升序排序。
练习案例的代码编写思路如下所示。
- 比较相邻的元素，如果第一个比第二个大，就交换两个元素。
- 对每一对相邻元素做同样的工作，执行完毕后，找到第一个最大值。
- 重复以上的步骤，每次比较次数-1，直到不需要比较。
练习案例的代码如下所示。
#include<iostream>
using namespace std;
int main()
{
//利用冒泡排序实现升序序列
int arr[9] = { 4,2,8,0,5,7,1,3,6,9 };
cout << "排序前：" << endl;
for (int i = 0; i < 10; i++)
{
cout << arr[i] << " ";
}
cout << endl;
//开始冒泡排序
//总共排序轮数为：元素个数-1
for (int i = 0; i < 10 - 1; i++)
{
//内层循环对比：次数 = 元素个数 - 当前轮数 - 1
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;
}
}
}
//排序后结果
cout << "排序后：" << endl;
for (int i = 0; i < 10; i++)
{
cout << arr[i] << " ";
}
cout << endl;
system("pause");
return 0;
}
排序前：
4 2 8 0 5 7 1 3 6 9
排序后：
0 1 2 3 4 5 6 7 8 9
3. 二维数组
二维数组就是在一维数组上，多加一个维度。
3.1 二维数组定义方式
二维数组定义的四种方式：
数据类型 数组名[ 行数 ][ 列数 ];数据类型 数组名[ 行数 ][ 列数 ] = { {数据1，数据2 } ，{数据3，数据4 } };数据类型 数组名[ 行数 ][ 列数 ] = { 数据1，数据2，数据3，数据4};数据类型 数组名[ ][ 列数 ] = { 数据1，数据2，数据3，数据4};
以上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. 数据类型 数组名[ 行数 ][ 列数 ];
cout << "第一种二维数组定义方式：" << endl;
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;
//外侧循环打印行数，内侧循环打印列数
for (int i = 0; i < 2; i++)
{
for (int j = 0; j < 3; j++)
{
cout << arr1[i][j] << endl;
}
}
// 2. 数据类型 数组名[ 行数 ][ 列数 ] = { {数据1，数据2 } ，{数据3，数据4 } };
cout << "第二种二维数组定义方式：" << endl;
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};
cout << "第三种二维数组定义方式：" << endl;
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};
cout << "第四种二维数组定义方式：" << endl;
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;
}
第一种二维数组定义方式：
1
2
3
4
5
6
第二种二维数组定义方式：
1 2 3
4 5 6
第三种二维数组定义方式：
1 2 3
4 5 6
第四种二维数组定义方式：
1 2 3
4 5 6
总结： 在定义二维数组时，如果初始化了数据，可以省略行数。
3.2 二维数组数组名
二维数组数组名的作用：
- 查看二维数组所占内存空间；
- 获取二维数组首地址。
实例如下所示。
#include<iostream>
using namespace std;
int main()
{
//二维数组名称用途
//1. 可以查看占用内存空间大小
int arr[2][3] =
{
{1,2,3},
{4,5,6}
};
cout << "二维数组占用内存空间为：" << sizeof(arr) << endl;
cout<< "二维数组第一行占用内存空间为：" << sizeof(arr[0]) << endl;
cout << "二维数组第一个元素占用内存空间为：" << sizeof(arr[0][0]) << endl;
cout << "二维数组的行数为：" << sizeof(arr)/sizeof(arr[0]) << endl;
cout << "二维数组的列数为：" << sizeof(arr[0]) / sizeof(arr[0][0]) << endl;
//2.获取二维数组首地址
cout << "二维数组首地址为：" << (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;
}
二维数组占用内存空间为：24
二维数组第一行占用内存空间为：12
二维数组第一个元素占用内存空间为：4
二维数组的行数为：2
二维数组的列数为：3
二维数组首地址为：13629368
二维数组第一行首地址为：13629368
二维数组第二行首地址为：13629380
二维数组第一个元素首地址为：13629368
二维数组第二个元素首地址为：13629372
总结： 1. 二维数组名就是这个数组的首地址；
2. 对二维数组名进行sizeof时，可以获取整个二维数组占用的内存空间大小。
3.3 二维数组应用案例
练习案例： 考试成绩统计。
案例描述： 有三名同学（张三，李四，王五），在一次考试中的成绩分别如下表，请分别输出三名同学的总成绩。
| 语文 | 数学 | 英语 | |
|---|---|---|---|
| 张三 | 100 | 100 | 100 |
| 李四 | 90 | 50 | 100 |
| 王五 | 60 | 70 | 80 |
练习案例的代码如下所示。
#include<iostream>
using namespace std;
#include<string>
int main()
{
//二维数组案例-考试成绩统计
//1.创建二维数组
int score[3][3] =
{
{100,100,100},
{90,50,100},
{60,70,80}
};
string names[3] = { "张三", "李四", "王五" };
//2.统计每个人的总和分数
for (int i = 0; i < 3; i++)
{
int sum = 0; //统计分数总和变量
for (int j = 0; j < 3; j++)
{
sum += score[i][j];
}
cout << names[i] << "的总分为：" <<sum << endl;
}
system("pause");
return 0;
}
张三的总分为：300
李四的总分为：240
王五的总分为：210
4. 总结
33万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
