05x数组42-49-优快云博客

本文链接：https://blog.youkuaiyun.com/Bugatti100Peagle/article/details/145380945

关注公众号，后台回复 找书+ C++Primer 获取C++相关电子书。

C++ 支持数组数据结构，它可以存储一个固定大小的相同类型元素的顺序集合。数组是用来存储一系列数据，但它往往被认为是一系列相同类型的变量。

在 C++ 中要声明一个数组，需要指定元素的类型和元素的数量，如下所示：

type arrayName [ arraySize ]; //注意下标从0开始

新建、赋值与使用

#include <iostream>
using namespace std;

int main() {
    // 新建一个数组，长度为5
    int arr[5] = {};

    // 赋值数组
    for (int i = 0; i < 5; i++) {
        arr[i] = i * 2; // 将数组的每个元素赋值为其索引的两倍
    }

    // 使用数组，输出数组的每个元素
    cout << "数组的元素为：" << endl;
    for (int i = 0; i < 5; i++) {
        cout << "arr[" << i << "] = " << arr[i] << endl;
    }

    return 0;
}

一维数组名的用途

统计数组再内存中的长度。
获取数组再内存中的首地址。

#include <iostream>
using namespace std;

int main() {
    // 新建一个数组，长度为5
    int arr[5] = {0, 1, 2, 3, 4};

    // 统计数组在内存中的长度
    int arraySize = sizeof(arr) / sizeof(arr[0]);
    cout << "数组的长度为：" << arraySize << endl;

    // 获取数组在内存中的首地址
    cout << "数组在内存中的首地址为：" << arr << endl;

    // 使用数组，输出数组的每个元素
    cout << "数组的元素为：" << endl;
    for (int i = 0; i < arraySize; i++) {
        cout << "arr[" << i << "] = " << arr[i] << endl;
    }

    return 0;
}

两个地址段差多少

这两个地址相差的长度可以通过简单的减法计算：

地址1（数组 arr）：000000000014FD08
地址2（数组 arrb）：000000000014FD38

将它们转换为十进制并相减即可：

000000000014FD38 - 000000000014FD08 = 0x30

换算为十进制：

0x30 = 48 字节

因此，这两个地址相距 48 字节。

在这个上下文中，两个数组 arr 和 arrb 都是长度为 6 的数组，而它们的首地址相距 48 字节，这可以通过以下几点来理解：

1. 数组的数据类型决定了内存占用

数组在内存中的总大小取决于其元素的数据类型和长度。如果数组 arr 和 arrb 的长度都是 6，那么每个数组占用的字节数为：
$
\text{数组总大小} = \text{每个元素的大小} \times \text{数组长度}
$

假设 arr 和 arrb 是以下几种常见的数据类型：

int 类型：在大多数 64 位系统中，int 的大小是 4 字节，因此一个长度为 6 的数组占用 $\times 6 = 24$ 字节。
float 类型：float 通常也是 4 字节，因此数组占用同样是 24 字节。
double 类型：double 通常是 8 字节，因此数组占用 $\times 6 = 48$ 字节。

2. 地址差说明内存布局

两个数组的首地址相距 48 字节，说明在内存中它们是连续分布的：

如果数组的元素是 double 类型，每个数组正好占用 48 字节，因此 arrb 的起始地址正好紧接在 arr 的末尾。
如果数组的元素是 int 或 float 类型（占 24 字节），那么地址间的 48 字节 说明两者之间存在 24 字节的对齐间隔，可能是由于内存对齐或其他结构性分配导致。

3. 内存对齐的可能性

内存对齐是编译器在分配内存时，为了提高访问效率而自动插入的间隔。比如：

如果系统要求数据按 8 字节对齐，则即使 arr 只占 24 字节，下一个数组 arrb 的起始地址也会向上对齐到最近的 8 字节倍数，这可能导致实际间隔增加。

结论

如果 arr 和 arrb 是 double 类型数组，两个地址相距正好等于 arr 的大小（48 字节），表示没有额外间隔。
如果是其他数据类型，可能由于内存对齐或其他原因，导致间隔大于数组的实际大小。

要具体确认，可以查看数组的数据类型和系统的对齐策略。

练习案例-5只小猪称体重

#include <iostream>
using namespace std;

int main() {
    // 新建一个数组，长度为5，存储五只小猪的体重
    int weights[5] = { 250, 300, 275, 320, 290 };

    // 输出每只小猪的体重
    cout << "五只小猪的体重分别为：" << endl;
    for (int i = 0; i < 5; i++) {
        cout << "小猪 " << i + 1 << " 的体重是 " << weights[i] << " 公斤" << endl;
    }

    // 找出最重的小猪
    int maxWeight = weights[0]; //已经从0下表开始找了
    int maxIndex = 0;
    for (int i = 1; i < 5; i++) {
        if (weights[i] > maxWeight) {
            maxWeight = weights[i];
            maxIndex = i;
        }
    }

    // 输出最重的小猪
    cout << "最重的小猪是小猪 " << maxIndex + 1 << "，体重是 " << maxWeight << " 公斤" << endl;

    return 0;
}

未命名的设计

练习案例-数组元素逆置

#include <iostream>
using namespace std;

int main() {
    // 新建一个数组，长度为5
    int weights[5] = { 250, 300, 275, 320, 290 };

    // 输出原始数组
    cout << "原始数组的元素为：" << endl;
    for (int i = 0; i < 5; i++) {
        cout << weights[i] << " ";
    }
    cout << endl;

    // 逆置数组元素
    int start = 0;
    int end = 4; // 数组下标从0开始，所以最后一个元素的下标为4 也可以用 sizeof(weights[0]) - 1
    while (start < end) {
        int temp = weights[start];
        weights[start] = weights[end];
        weights[end] = temp;
        start++;
        end--;
    }x

    // 输出逆置后的数组
    cout << "逆置后的数组元素为：" << endl;
    for (int i = 0; i < 5; i++) {
        cout << weights[i] << " "; // 末尾加空字符串
    }
    cout << endl;

    return 0;
}

经典算法-冒泡排序

#include <iostream>
using namespace std;

// 定义颜色代码
#define RESET   "\033[0m"
#define RED     "\033[31m"
#define GREEN   "\033[32m"
#define YELLOW  "\033[33m"
#define BLUE    "\033[34m"
#define MAGENTA "\033[35m"
#define CYAN    "\033[36m"
#define WHITE   "\033[37m"

int main() {
    // 新建一个数组，长度为5
    int weights[5] = { 22, 34, 21, 28, 36 };

    // 输出原始数组
    cout << "原始数组的元素为：" << endl;
    for (int i = 0; i < 5; i++) {
        cout << weights[i] << " ";
    }
    cout << endl;

    // 冒泡排序算法，按降序排列
    for (int i = 0; i < 5 - 1; i++) {
        for (int j = 0; j < 5 - 1 - i; j++) {
            bool swapped = false;
            if (weights[j] < weights[j + 1]) {
                int temp = weights[j];
                weights[j] = weights[j + 1];
                weights[j + 1] = temp;
                swapped = true;
            }

            // 输出每次排序后的数组
            cout << "第 " << i + 1 << " 轮，第 " << j + 1 << " 次排序后的数组元素为：" << endl;
            for (int k = 0; k < 5; k++) {
                if (k == j || k == j + 1) {
                    cout << RED << weights[k] << " " << RESET; // 用红色标记被动过的元素
                }
                else {
                    cout << weights[k] << " ";
                }
            }
            cout << endl;
        }
    }

    // 输出最终排序后的数组
    cout << "最终降序排列后的数组元素为：" << endl;
    for (int i = 0; i < 5; i++) {
        cout << weights[i] << " ";
    }
    cout << endl;

    return 0;
}

二维数组

可以通过数组名查看：

统计数组再内存中的长度。
获取数组再内存中的首地址。

多维数组最简单的形式是二维数组。一个二维数组，在本质上，是一个一维数组的列表。声明一个 x 行 y 列的二维整型数组，形式如下：

type arrayName [ x ][ y ];

初始化二维数组

多维数组可以通过在括号内为每行指定值来进行初始化。下面是一个带有 3 行 4 列的数组。

int a[3][4] = {  
 {0, 1, 2, 3} ,   /*  初始化索引号为 0 的行 */
 {4, 5, 6, 7} ,   /*  初始化索引号为 1 的行 */
 {8, 9, 10, 11}   /*  初始化索引号为 2 的行 */
};

内部嵌套的括号是可选的，下面的初始化与上面是等同的：

int a[3][4] = {0,1,2,3,4,5,6,7,8,9,10,11};
int a[][4] = {0,1,2,3,4,5,6,7,8,9,10,11}; //可以省行数，但是不能省列数，且要有数据

访问二维数组元素

二维数组中的元素是通过使用下标（即数组的行索引和列索引）来访问的。例如：

int val = a[2][3];

属性用法

#include <iostream>
using namespace std;

int main() {
    // 新建一个二维数组，3行3列，数字为1到9
    int arr[3][3] = {
        {1, 2, 3},
        {4, 5, 6},
        {7, 8, 9}
    };

    // 输出数组的内容
    cout << "数组的内容为：" << endl;
    for (int i = 0; i < 3; i++) {
        for (int j = 0; j < 3; j++) {
            cout << arr[i][j] << " ";
        }
        cout << endl;
    }

    // 输出行数和列数
    int rows = sizeof(arr) / sizeof(arr[0]);
    int cols = sizeof(arr[0]) / sizeof(arr[0][0]);
    cout << "数组的行数为：" << rows << endl;
    cout << "数组的列数为：" << cols << endl;

    // 输出总内存空间
    int totalSize = sizeof(arr);
    cout << "数组的总内存空间为：" << totalSize << " 字节" << endl;

    // 输出每一列的内存空间和首地址
    for (int j = 0; j < cols; j++) {
        int colSize = sizeof(arr[0][j]) * rows;
        cout << "第 " << j + 1 << " 列的内存空间为：" << colSize << " 字节" << endl;
        cout << "第 " << j + 1 << " 列的首地址为：" << &arr[0][j] << endl;
    }

    return 0;
}

练习案例-考试成绩

#include <iostream>
using namespace std;

int main() {
    // 新建一个二维数组，存储三名同学在三门考试科目中的成绩
    int scores[3][3] = {
        {85, 92, 78}, // 张三的成绩：语文85，英语92，数学78
        {88, 76, 90}, // 李四的成绩：语文88，英语76，数学90
        {90, 85, 88}  // 王五的成绩：语文90，英语85，数学88
    };

    // 定义同学和科目的名称
    string students[3] = { "张三", "李四", "王五" };
    string subjects[3] = { "语文", "英语", "数学" };

    // 分别输出每位同学的成绩和总分
    for (int i = 0; i < 3; i++) {
        int totalScore = 0; // 初始化总分
        cout << students[i] << "的成绩：" << endl;
        for (int j = 0; j < 3; j++) {
            cout << subjects[j] << "：" << scores[i][j] << "分" << endl;
            totalScore += scores[i][j]; // 累加每门科目的成绩
        }
        cout << "总分：" << totalScore << "分" << endl;
        cout << endl;
    }

    return 0;
}

C++ 中数组详解

在 C++ 中，数组是非常重要的，我们需要了解更多有关数组的细节。下面列出了 C++ 程序员必须清楚的一些与数组相关的重要概念：

概念	描述
多维数组	C++ 支持多维数组。多维数组最简单的形式是二维数组。
指向数组的指针	您可以通过指定不带索引的数组名称来生成一个指向数组中第一个元素的指针。您可以先跳过本章，等了解了 C++ 指针的概念之后，再来学习本章的内容。
传递数组给函数	您可以通过指定不带索引的数组名称来给函数传递一个指向数组的指针。
从函数返回数组	C++ 允许从函数返回数组。

🔔 想要获取更多网络安全与编程技术干货？

关注 泷羽Sec-静安 公众号，与你一起探索前沿技术，分享实用的学习资源与工具。我们专注于深入分析，拒绝浮躁，只做最实用的技术分享！💻

扫描下方二维码，马上加入我们，共同成长！🌟

👉 长按或扫描二维码关注公众号