一、 数组概述

1.1 介绍

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

1.2 特点

1、数组中的每个元素都是相同的数据类型；

2、数组是由连续的内存位置组成的。

二、一维数组

2.1 一维数组的定义方式

定义方式可分为三种：

1、数据类型 数组名 [ 数组长度 ]；

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

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

2.1.1  数据类型 数组名 [ 数组长度 ]；

代码示例：

#include<iostream>
using namespace std;

int main()
{
	//数据类型 数组名 [ 数组长度 ]；
	int str[5];
	//注意其中5是数组长度，代表5个，而数组元素的下标是从0开始索引的
	//注意[]中括号内的数字在C++中，有其专属名词“下标”
	//注意数组长度要为常量，不可为变量

	//给数组中的元素进行赋值
	str[0] = 1;
	str[1] = 2;
	str[2] = 3;
	str[3] = 4;
	str[4] = 5;

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

	system("pause");
	return 0;
}

注意：定义数组的时候，必须有初始长度，否则将报错，显示“不允许使用不完整的类型”，如下：

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

该定义方式，会出现几种不同的情况。

首先在 数组长度=大括号内的数值个数时，如：int str[5] = { 1,2,3,4,5 };，正常输出，代码如下：

#include<iostream>
using namespace std;

int main()
{
	//数据类型 数组名 [ 数组长度 ] = {数值1，数值2，数值3……}；
	int str[5] = { 1,2,3,4,5 };

	/*
	cout << str[0] << endl;
	cout << str[1] << endl;
	cout << str[2] << endl;
	cout << str[3] << endl;
	cout << str[4] << endl;
	*/
	//这样过于麻烦
	//利用循环输出数组元素
	for (int i = 0; i < 5; i++)
	{
		cout << str[i] << endl;
	}

	system("pause");
	return 0;
}

运行结果：

 数组长度>大括号内的数值个数时，如：int str[5] = { 1,2,3 };则未赋值的默认为“0”，结果如下：

 数组长度<大括号内的数值个数时，如：int str[5] = { 1,2,3,4,5,6,7 };则此时系统会报错，结果如下：

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

代码示例如下：

#include<iostream>
using namespace std;

int main()
{
	//数据类型 数组名 [  ] = {数值1，数值2，数值3……}；
	int str[] = { 9,8,7,6,5,4,3,2,1 };

	for (int i = 0; i < 9; i++)
	{
		cout << str[i] << endl;
	}
	system("pause");
	return 0;
}

2.2  一维数组数组名

用途：

2.2.1  统计整个数组在内存中的长度

前面我们使用过sizeof关键字，用于统计数据类型所占内存的大小，同样这也可以用在数组中，如下：

数组占用内存空间大小：sizeof(str)

数组单个元素占用内存空间大小：sizeof(str[0])

数组长度：sizeof ( str )  /  sizeof ( str[0] )

sizeof关键字的运用：sizeof关键字运用_时光の尘的博客-CSDN博客

代码示例：

#include<iostream>
using namespace std;

int main()
{
	int str[10] = { 1,2,3,4,5,6,7,8,9,10 };

	cout << "整个数组占用的内存空间为：" << sizeof(str) << endl;
	cout << "每个元素占用的内存空间为：" << sizeof(str[0]) << endl;
	cout << "数组元素个数：" << sizeof(str) / sizeof(str[0]) << endl;

	system("pause");
	return 0;
}

运行结果：

2.2.2  获取数组在内存中的首地址

获取数组首地址：str 或 &str[0]。

这两个都能获取到数组首地址，不同的是&str[0]，可以通过改变下标，来获取本数组内其他元素的地址。

代码示例：

#include<iostream>
using namespace std;

int main()
{
	int str[10] = { 1,2,3,4,5,6,7,8,9,10 };

	cout << "数组的首地址为：" << str << endl;	
	
	//转换成十进制
	cout << "数组的首地址为：" << int(str) << endl;

	cout << "数组中第一个元素的地址为：" << &str[0] << endl;

	//转换成十进制
	cout << "数组中第一个元素的地址为：" << (int)&str[0] << endl;
	cout << "数组中第二个元素的地址为：" << (int)&str[1] << endl;

	//注意：数组名是个常量，不可以进行赋值操作

	system("pause");
	return 0;
}

运行结果：

 从结果可以看出，首地址和第一个元素地址是相同的，且第二个元素和第一个元素相差4，这个原因是因为我们设的是整型变量，其所占内存空间为4。

2.3  一维数组练习

一维数组练习（五只小猪称体重、元素逆置）_时光の尘的博客-CSDN博客

2.4  冒泡排序

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

        1、比较相邻的元素，如果第一个比第二个大，就交换它们，一共比较8次。第一轮比较完成之后就会得到最大值9。

        2、重复步骤1，直到排序完成，第二轮比较时，因为已经找出最大数，此时不需要再将9加入比较，所以比较的元素-1，相应的比较次数也会-1；

       3、 依此类推，直到按升序找出所有数，停止比较。如下图：

可知： 

排序总轮数 = 元素个数 - 1

每轮对比次数 = 剩余元素个数 - 1

剩余元素个数 = 元素个数 - 排序轮数

代码示例：

#include <iostream>
using namespace std;
int main()
{
   //利用冒泡排序实现升序和降序
    int str[9] = { 1,6,8,4,2,3,9,7,5 };

    //打印排序前序列
    cout << "进行排序前为：";
    for (int i = 0; i < sizeof(str) / sizeof(str[0]); i++)
        //for (int i = 0; i < 9; i++)，后续代码同理
    {
        cout << str[i] << " ";
    }
    cout << endl;

    //升序排序
    for (int i = 0; i < sizeof(str) / sizeof(str[0]) - 1; i++)//排序轮数
    {
        for (int j = 0; j < sizeof(str) / sizeof(str[0]) - i - 1; j++)//每轮比较次数
        {
            if (str[j] > str[j + 1])//如果想要实现降序排列，改为 if (str[j] < str[j + 1])
            {
                int temp = str[j + 1];//交换
                str[j + 1] = str[j];
                str[j] = temp;
            }
        }
    }
    cout << "升序排序后为：";
    for (int i = 0; i < sizeof(str) / sizeof(str[0]); i++)
    {
        cout << str[i] << " ";
    }
    cout << endl;

    //降序排序
    for (int i = 0; i < sizeof(str) / sizeof(str[0]) - 1; i++)//排序轮数
    {
        for (int j = 0; j < sizeof(str) / sizeof(str[0]) - i - 1; j++)//每轮比较次数
        {
            if (str[j] < str[j + 1])
            {
                int temp = str[j + 1];//交换
                str[j + 1] = str[j];
                str[j] = temp;
            }
        }
    }
    cout << "降序排序后为：";
    for (int i = 0; i < sizeof(str) / sizeof(str[0]); i++)
    {
        cout << str[i] << " ";
    }
    cout << endl;

    system("pause");
    return 0;
}

运行结果：

三、二维数组

3.1  二维数组定义方式

四种定义方式：

1、数据类型 数组名[ 行数 ][ 列数 ];

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

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

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

3.1.1  数据类型 数组名[ 行数 ][ 列数 ];

int str[2][3];

其代表的含义如下：

str[0][0]	str[0][1]	str[0][2]
str[1][0]	str[1][1]	str[1][2]

注意，同一维数组一样，其中2，3每行，每列的长度，而数组元素的下标是从0开始索引的。

代码示例：

#include<iostream>
using namespace std;

int main()
{
	//数据类型 数组名[ 行数 ][ 列数 ];
	int str[2][3];

	str[0][0] = 1;
	str[0][1] = 2;
	str[0][2] = 3;
	str[1][0] = 4;
	str[1][1] = 5;
	str[1][2] = 6;

	for (int i = 0; i < 2; i++)
	{
		for (int j = 0; j < 3; j++)
		{
			cout << str[i][j]<<" ";
		}
		cout << endl;
	}

	system("pause");
	return 0;
}

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

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

或者是

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

代码示例：

#include<iostream>
using namespace std;

int main()
{
	//数据类型 数组名[ 行数 ][ 列数 ] = { {数据1，数据2}，{数据3，数据4}……}；
	int str[4][3] =
	{
		{1,2,3},
		{4,5,6},
		{7,8,9},
		{4,2,1}
	};

	for (int i = 0; i < 4; i++)
	{
		for (int j = 0; j < 3; j++)
		{
			cout << str[i][j] << " ";
		}
		cout << endl;
	}

	system("pause");
	return 0;
}

和一维数组相似，在其正常情况下运行输出的结果：

 行数少掉一行的结果：

 多一行的结果：

 列上少元素的结果：

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

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

代码示例：

#include<iostream>
using namespace std;

int main()
{
	//数据类型 数组名[ 行数 ][ 列数 ] = { 数据1，数据2，数据3，数据4……}；
	int str[3][3] = { 1,2,3,4,5,6,7,8,9 };

	for (int i = 0; i < 3; i++)
	{
		for (int j = 0; j < 3; j++)
		{
			cout << str[i][j] << " ";
		}
		cout << endl;
	}

	system("pause");
	return 0;
}

同样的其输出情况和3.1.3类似，这里给出了其缺少元素的输出，如下：

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

int str[][3] = { 1,2,3,4,5,6,7,8,9 };其代表：

1	2	3
4	5	6
7	8	9

int str[][3] = { 1,2,3,4,5,6 };其代表：

1	2	3
4	5	6

编译器可以根据列数，推测出所需行数，但是不能根据行数，推测出所需列数，因此若是写成int str[3][] = { 1,2,3,4,5,6 };将会报错。

因为编译器可以根据列数往每行上补齐元素，要是最后一行元素不够可以补零，而若是只给行数并不能确定，每行上要补几个元素，会有很多情况。

代码示例：

#include<iostream>
using namespace std;

int main()
{
	//数据类型 数组名[  ][ 列数 ] = { 数据1，数据2，数据3，数据4……}；
	int str[][3] = { 1,2,3,4,5,6,7 };

	for (int i = 0; i < 3; i++)
	{
		for (int j = 0; j < 3; j++)
		{
			cout << str[i][j] << " ";
		}
		cout << endl;
	}

	system("pause");
	return 0;
}

运行结果：

若是多出元素结果为：

值得注意的一点是，若是在元素不够写入另一行，且程序强制执行，将会出现下面情况：

3.2   二维数组数组名

作用：查看二维数组内存空间；获取二维数组首地址。

代码示例：

#include<iostream>
using namespace std;

int main()
{
	//查看内存占用空间的大小
	int str[2][3] =
	{
		{1,2,3},
		{4,5,6}
	};
	cout << "该二维数组占用内存空间的大小为：" << sizeof(str) << endl;
	cout << "该二维数组第一行占用内存空间的大小为：" << sizeof(str[0]) << endl;
	cout << "该二维数组第一个元素占用内存空间的大小为：" << sizeof(str[0][0]) << endl;
	cout << "该二维数组有多少行：" << sizeof(str)/sizeof(str[0]) << endl;
	cout << "该二维数组有多少列：" << sizeof(str[0]) / sizeof(str[0][0]) << endl;
	cout << "该二维数组有多少元素：" << sizeof(str) / sizeof(str[0][0]) << endl;

	//二维数组的首地址为多少
	cout << "二维数组的首地址为：" << (int)str << endl;
	cout << "二维数组的第一行首地址为：" << (int)str[0] << endl;
	cout << "二维数组的第一个元素的首地址为：" << (int)&str[0][0] << endl;
	cout << "二维数组的第二行首地址为：" << (int)str[1] << endl;
	cout << "二维数组的第二个元素的首地址为：" << (int)&str[0][1] << endl;

	system("pause");
	return 0;
}

运行结果：