# C++的数组

# 1. 数组特点

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

1. 特点1：数组中每个元素都是相同的数据类型。
2. 特点2：数组是由连续的内存位置组成的。

# 2. 一维数组

## 2.1 定义方式

① 一维数组定义：

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

② 数组名的命名规范与变量名命名规范一致，不要和变量重名。

③ 数组中下标是从0开始索引。


```python
#include <iostream>
using namespace std;

int main()
{
    //1、数组类型 数组名 [ 数组长度 ]
    int arr[5];
    //数组元素的下标是从0开始索引的
    //给数组中的元素进行赋值
    arr[0] = 10;
    arr[1] = 20;
    arr[2] = 30;
    arr[3] = 40;
    arr[4] = 50;


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

    //2、数据类型 数组名 [ 数组长度 ] = { 值1，值2，... }
    //如果在初始化数据的时候，没有完全填写完，会用0来填补剩余数据
    int arr2[5] = { 10,20,30 };

    /*
    方式一：
    cout << arr2[0] << endl;
    cout << arr2[1] << endl;
    cout << arr2[2] << endl;
    cout << arr2[3] << endl;
    cout << arr2[4] << endl;
    */


    // 方式二：利用循环输出数组中的元素
    for (int i = 0; i < 5; i++)
    {
        cout << arr2[i] << endl;
    }

    //3、数据类型 数组名 [ ] = { 值1，值2，.... }
    int arr3[] = { 90,80,70,60,50,40,30,20,10 };  //以后自定义变量，不要 int arr3 = 100，这样避免以后调用arr3到底是调用变量还是数组产生模糊。
    for (int i = 0; i < 9; i++)
    {
        cout << arr3[i] << endl;
    }
    
    system("pause");

    return 0;

}
```

运行结果：  
 - 10  
 - 20  
 - 30  
 - 40  
 - 50  
 - 10  
 - 20  
 - 30  
 - 0  
 - 0  
 - 90  
 - 80  
 - 70  
 - 60  
 - 50  
 - 40  
 - 30  
 - 20  
 - 10  
 - 请按任意键继续. . .

## 2.2 数组名

① 一维数组名的用途：

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


```python
#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;  //int使得将十六位地址通过int转换为10位地址，&表示取址符号，取一个元素的首地址
    cout << "数组中第二个元素地址为：" << (int)&arr[1] << endl;  //第二个元素和第一个元素差四个字节

    //数组名是常量，值为数组首地址，不可以进行赋值操作
    //arr = 100;  不可以这样赋值修改

    system("pause");

    return 0;

}
```

运行结果：  
 - 整个数组占用内存空间为：40  
 - 每个元素占用内存空间为：4  
 - 数组中元素的个数为：10  
 - 数组首地址为：12582108  
 - 数组中第一个元素地址为：12582108  
 - 数组中第二个元素地址为：12582112  
 - 请按任意键继续. . .

## 2.3 五只小猪称体重

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


```python
#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++)
    {
        //cout << arr[i] << endl;
        if (arr[i] > max)
        {
            max = arr[i];
        }
    }

    //3、打印最大值
    cout << max << endl;

    system("pause");

    return 0;

}
```

运行结果：  
 - 400  
 - 请按任意键继续. . .

## 2.4 数组元素逆置

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


```python
#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.5  冒泡排序

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

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

② 示例：将数组(4,2,8,0,5,7,1,3,9)进行排序。


```python
#include <iostream>
using namespace std;

int main()
{
    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;
    
    //开始冒泡排序
    for (int i = 0; i < 9 - 1; i++)
    {
        //内层循环对比  次数=元素个数=当前轮数-1
        for (int j = 0; j < 9 - 1 - i; 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 < 9; i++)
    {
        cout << arr[i] << " ";
    }
    cout << endl;

    system("pause");

    return 0;
}
```

运行结果：  
 - 排序前  
 - 4 2 8 0 5 7 1 3 9  
 - 排序后  
 - 0 1 2 3 4 5 7 8 9  
 - 请按任意键继续. . .

运行结果：  


# 3. 二维数组

## 3.1 定义方式

① 二维数组就是在一维数组上，多加一个维度。

![image.png](13_C++的数组_files/image.png)

② 二维数组定义的四种方式：

1. 数据类型 数组名 [ 行数 ][ 列数 ];
2. 数据类型 数组名 [ 行数 ][ 列数 ] = { { 数据1，数据2} , { 数据3，数据4 } }
3. 数据类型 数组名 [ 行数 ][ 列数 ] = { 数据1，数据2，数据3，数据4 };
4. 数据类型 数组名 [ ][ 列数 ] = { 数据1，数据2，数据3，数据4 };

③ 以上4种定义方式，利用第二种更加直观，提高代码的可读性。

④ 定义二维数组的时候，如果初始化了数据，可以省略行数。


```python
#include <iostream>
using namespace std;

int main()
{

    //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] << endl;
        }
    }

    //2、数据类型 数组名 [ 行数 ][ 列数 ] = { { 数据1，数据2} , { 数据3，数据4 } }
    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 };
    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 << arr2[i][j] << " ";
        }
        cout << endl;
    }

    //4、数据类型 数组名 [  ][ 列数 ] = { 数据1，数据2，数据3，数据4 };
    int arr4[][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;
    }

    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 数组名

① 查看二维数组所占内存空间。

② 获取二维数组首地址。


```python
#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 << endl;
    cout << "二维数组第一行首地址为：" << (int)arr[0] << endl;
    cout << "二维数组第二行首地址为：" << (int)arr[1] << endl;

    cout << "二维数组第一个元素首地址为：" << (int)&arr[0][0] << endl;
    cout << "二维数组第二个元素首地址为：" << (int)&arr[0][1] << endl;  //每个元素地址相差4个字节

    system("pause");

    return 0;

}
```

运行结果：  
 - 二维数组占用内存空间为： 24  
 - 二维数组第一行占用内存为：12  
 - 二维数组第一个元素占用内存为：4  
 - 二维数组行数为：2  
 - 二维数组列数为：3  
 - 二维数组首地址为：3733652  
 - 二维数组第一行首地址为：3733652  
 - 二维数组第一行首地址为：3733652  
 - 二维数组第二行首地址为：3733664  
 - 二维数组第一个元素首地址为：3733652  
 - 二维数组第二个元素首地址为：3733656  
 - 请按任意键继续. . .

## 3.3 考试成绩

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

| 姓名 | 语文 | 数学 | 英语 |
| :------:| :------: | :------: | :------: |
| 张三 | 100 | 100 | 100 |
| 李四 | 90 | 50 | 100 |
| 王五 | 60 | 70 | 80 |


```python
#include <iostream>
using namespace std;

int main()
{
    //二维数组案例-考试成绩统计
    //1、创建二维数组
    int scores[3][3] =
    {
        {100,100,100},
        {90,50,100},
        {60,70,80}
    };

    //2、统计每个人的总和分数
    for (int i = 0; i < 3; i++)
    {
        int sum = 0; //统计分数总和不变
        for (int j = 0; j < 3; j++)
        {
            sum += scores[i][j];
            //cout << scores[i][j] << " ";
        }
        cout << "第" << i + 1 << "个人的总分为：" << sum << endl;
    }

    system("pause");

    return 0;
}
```

运行结果：  
 - 第1个人的总分为：300  
 - 第2个人的总分为：240  
 - 第3个人的总分为：210  
 - 请按任意键继续. . .