嵌入式C语言：一维数组

byte轻骑兵

发布于 2026-01-21 14:32:20

1360

在嵌入式系统开发中，一维数组是C语言中一种基本的数据结构，用于存储相同类型的多个元素。

一、定义

在嵌入式 C 语言中，一维数组是一种基本的数据结构，用于存储一组相同类型的数据元素。它可以被看作是一个连续的内存块，其中每个元素都有相同的大小并且按照顺序排列。

一维数组的定义方式如下：

数据类型 数组名[数组大小];

例如，定义一个存储5个整数的数组：

int numbers[5];

数据类型可以是基本数据类型（如int、char、float等），也可以是用户自定义的数据类型（如结构体、枚举等）。

二、内存布局

在C语言中，数组元素在内存中是连续存储的，意味着数组的每个元素都紧挨着前一个元素，并且每个元素都占用相同大小的内存空间。这种连续的内存布局有几个重要的含义：

地址计算：给定数组的起始地址和元素的大小，可以很容易地计算出数组中任意元素的地址。对于int arr[5];，如果起始地址是0x1000，并且int类型占4个字节，那么arr[i]的地址就是起始地址 + i * 元素大小。因此，arr[0]的地址是0x1000，arr[1]的地址是0x1000 + 4（即0x1004），以此类推。
指针运算：由于数组元素在内存中是连续的，因此可以使用指针来遍历数组。指针可以看作是一个变量，它存储了内存地址。通过给指针加上或减去一个整数，可以移动到数组中的下一个或上一个元素（假设这个整数是元素的大小）。这种指针运算在C语言中非常常见，特别是在处理数组和字符串时。
性能优势：连续的内存布局可以提高数组访问的性能。当数组元素在内存中是连续存储的，CPU可以更有效地缓存这些元素，从而减少内存访问的延迟。对于嵌入式系统来说尤其重要，因为嵌入式系统通常对性能有很高的要求，并且内存资源有限。
数组越界的风险：由于数组元素是连续存储的，因此如果访问了数组的有效范围之外的元素（即数组越界），就可能会覆盖内存中的其他数据，导致程序崩溃或数据损坏。在嵌入式系统中，这种错误可能会导致更严重的后果，因为嵌入式系统通常运行着关键任务，并且资源有限。

三、数组的初始化

3.1. 完全初始化

当希望数组的所有元素在定义时都具有特定的值时，可以使用完全初始化。在完全初始化中，需要为数组的每个元素提供一个初始值。

int arr[3] = {1, 2, 3};

arr[0]被初始化为1，arr[1]被初始化为2，arr[2]被初始化为3。由于提供了数组的所有元素的初始值，因此这是一种完全初始化。

3.2. 部分初始化

有时，可能只希望初始化数组的一部分元素，而其他元素则保持未初始化状态。在C语言中，当部分初始化一个数组时，未指定的元素会自动被初始化为0（对于全局数组或静态数组）或者保持为不确定的值（对于局部数组，即函数内部定义的数组）。

int arr[5] = {1, 2};

arr[0]被初始化为1，arr[1]被初始化为2。对于全局数组或静态数组，arr[2]、arr[3]和arr[4]会被自动初始化为0。然而，如果arr是一个局部数组，这些未初始化的元素将包含不确定的值。

3.3. 不指定大小初始化

当初始化一个数组时，可以省略数组的大小。编译器会根据提供的初始值的数量自动确定数组的大小。

int arr[] = {1, 2, 3, 4};

编译器会自动将数组arr的大小确定为4，因为它包含了4个初始值。这种初始化方式在不知道数组将包含多少个元素，但希望在定义时提供所有元素的值时非常有用。

四、使用数组

4.1. 访问数组元素

4.1.1. 通过索引访问数组元素

数组元素通过索引访问，索引从0开始。意味着第一个元素的索引是0，第二个元素的索引是1，依此类推。

int numbers[5] = {1, 2, 3, 4, 5};
int firstNumber = numbers[0]; // firstNumber 的值为 1

在嵌入式系统中，这种访问方式非常常见，比如读取传感器数据并存储在数组中，或者将控制命令发送到执行器，这些数据可能以数组的形式存在并进行处理。

4.1.2. 通过指针访问数组元素

数组名在大多数情况下会被解释为指向数组首元素的指针。因此，可以使用指针来访问数组元素。

int arr[5] = {10, 20, 30, 40, 50};
int *p = arr; // p现在指向arr的首元素，即arr[0]
int secondElement = p[1]; // secondElement的值为20，因为p[1]等同于arr[1]

指针访问在处理动态内存分配或在函数间传递数组时特别有用。例如，在嵌入式系统中，可能有一个函数需要处理来自传感器的数据数组。可以将这个数组作为指针参数传递给函数，这样函数就可以直接访问和修改数组元素

4.2. 遍历数组

在嵌入式系统中，遍历数组是一项基本且常见的任务。通过遍历数组，可以对每个元素执行特定的操作，例如计算总和、查找最大值或最小值、打印数组内容等。遍历数组通常通过循环来实现，无论是for循环、while循环还是do-while循环。

以下是遍历数组的基本步骤：

初始化循环变量：通常，会使用一个整数变量作为循环变量（也称为索引或计数器），并将其初始化为0（因为数组索引从0开始）。
设置循环条件：循环将继续执行，直到循环变量的值达到或超过数组的大小。
更新循环变量：在每次循环迭代结束时，增加循环变量的值（通常是加1）。
访问数组元素：在循环体内，使用循环变量作为索引来访问数组元素，并对该元素执行所需的操作。

代码示例：以下是一个使用for循环遍历数组并计算总和的示例：

#include <stdio.h>
 
int main() {
    int numbers[5] = {1, 2, 3, 4, 5};
    int sum = 0;
 
    // 使用for循环遍历数组
    for (int i = 0; i < 5; i++) {
        sum += numbers[i]; // 将当前元素的值加到总和中
    }
 
    // 打印总和
    printf("The sum of the array elements is: %d\n", sum);
 
    return 0;
}

查找最大值的示例：以下是另一个使用for循环遍历数组并查找最大值的示例：假设数组的第一个元素是最大值，并使用for循环遍历数组的其余部分。如果找到比当前最大值更大的元素，就更新最大值。

4.3. 数组作为函数参数

在嵌入式C语言中，当数组作为函数参数时，实际上传递的是数组的首地址（即一个指向数组首元素的指针）。由于数组名在大多数情况下会被解释为指向其首元素的指针，因此在函数声明和定义中，数组参数通常被声明为指针类型。同时，由于函数本身并不接收数组的大小信息，通常需要额外传递一个表示数组大小的参数。

以下代码示例，展示了如何将数组作为函数参数传递，并在函数内部处理数组：

#include <stdio.h>
 
// 函数声明，接受一个整数指针和数组大小作为参数
void processArray(int *arr, int size);
 
int main() {
    // 定义一个整数数组
    int numbers[] = {1, 2, 3, 4, 5};
    // 获取数组的大小（元素个数）
    int size = sizeof(numbers) / sizeof(numbers[0]);
 
    // 调用函数，传递数组和大小
    processArray(numbers, size);
 
    return 0;
}
 
// 函数定义，遍历数组并打印每个元素
void processArray(int *arr, int size) {
    for (int i = 0; i < size; i++) {
        printf("%d ", arr[i]); // 使用指针访问数组元素
    }
    printf("\n");
}

需要注意的是，虽然使用了数组名numbers作为函数参数，但在函数声明和定义中，将参数类型声明为指针int *。这是因为当数组名作为函数参数时，它会自动退化为指向其首元素的指针。

此外，由于函数本身不接收数组的大小信息，因此必须手动传递一个表示数组大小的参数。通常是通过计算数组的总大小除以单个元素的大小来得到的（如sizeof(numbers) / sizeof(numbers[0])所示）。这样做可以确保在函数内部能够正确地处理数组中的所有元素。

五、应用场景

5.1. 数据采集与存储

在嵌入式系统中，可能需要定期从传感器采集数据，并将这些数据存储在一个数组中，以便后续处理。以下是一个简单的例子，模拟从温度传感器采集数据并计算平均值：

#include <stdio.h>
 
#define NUM_SAMPLES 10
 
int main() {
    int temperatures[NUM_SAMPLES]; // 存储温度数据的数组
    int sum = 0;
 
    // 模拟采集数据
    for (int i = 0; i < NUM_SAMPLES; i++) {
        // 在实际应用中，这里应该是从传感器读取数据的代码
        temperatures[i] = (i + 1) * 10; // 假设温度数据是递增的，仅作为示例
        sum += temperatures[i];
    }
 
    // 计算平均值
    float average = sum / (float)NUM_SAMPLES;
    printf("Average temperature: %.2f\n", average);
 
    return 0;
}

5.2. 数据缓冲

在串口通信中，接收到的数据可能需要先存储在一个缓冲数组中，然后再进行解析。以下是一个简单的例子，模拟串口接收数据并存储在数组中：

#include <stdio.h>
#include <string.h>

#define BUFFER_SIZE 100

int main() {
    char buffer[BUFFER_SIZE]; // 存储接收数据的数组
    int index = 0;

    // 模拟接收到的数据
    char *receivedData = "Hello, Embedded World!";

    // 将数据复制到缓冲区中（在实际应用中，通常是由串口中断处理函数完成的）
    while (index < BUFFER_SIZE - 1 && receivedData[index] != '\0') {
        buffer[index++] = receivedData[index];
    }
    buffer[index] = '\0'; // 确保字符串以空字符结尾

    // 解析并打印接收到的数据
    printf("Received data: %s\n", buffer);

    return 0;
}

5.3. 查找与排序

以下是一个使用冒泡排序算法对整数数组进行排序，并查找特定元素的例子：

#include <stdio.h>

#define ARRAY_SIZE 10

// 冒泡排序函数
void bubbleSort(int arr[], int size) {
    for (int i = 0; i < size - 1; i++) {
        for (int j = 0; j < size - i - 1; j++) {
            if (arr[j] > arr[j + 1]) {
                // 交换元素
                int temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
    }
}

// 线性查找函数
int linearSearch(int arr[], int size, int target) {
    for (int i = 0; i < size; i++) {
        if (arr[i] == target) {
            return i; // 返回找到的元素的索引
        }
    }
    return -1; // 如果未找到，则返回-1
}

int main() {
    int numbers[ARRAY_SIZE] = {5, 3, 8, 6, 2, 7, 4, 1, 9, 0};
    int target = 6;

    // 对数组进行排序
    bubbleSort(numbers, ARRAY_SIZE);

    // 打印排序后的数组
    printf("Sorted array: ");
    for (int i = 0; i < ARRAY_SIZE; i++) {
        printf("%d ", numbers[i]);
    }
    printf("\n");

    // 查找目标元素
    int index = linearSearch(numbers, ARRAY_SIZE, target);
    if (index != -1) {
        printf("Element %d found at index %d.\n", target, index);
    } else {
        printf("Element %d not found.\n", target);
    }

    return 0;
}