C语言数组初始化的多种方法
静态数组初始化
完全初始化
在C语言中，对于静态数组（在函数外部定义或者使用 static 关键字在函数内部定义的数组），可以在定义时进行完全初始化。例如：
#include <stdio.h>
// 全局静态数组
int globalArray[5] = {1, 2, 3, 4, 5};
int main() {
// 局部静态数组
static int localStaticArray[3] = {10, 20, 30};
for (int i = 0; i < 5; i++) {
printf("globalArray[%d] = %d\n", i, globalArray[i]);
}
for (int i = 0; i < 3; i++) {
printf("localStaticArray[%d] = %d\n", i, localStaticArray[i]);
}
return 0;
}
在上述代码中，globalArray 是一个全局静态数组，在定义时被初始化为 {1, 2, 3, 4, 5}。localStaticArray 是一个局部静态数组，在 main 函数内部定义并初始化为 {10, 20, 30}。
这种初始化方式非常直观，数组的每个元素都被明确赋予了初始值。编译器会按照初始化列表中的顺序依次为数组元素赋值。
部分初始化
静态数组也支持部分初始化。当初始化列表中的值少于数组元素个数时，剩余的元素会被自动初始化为0（对于整型数组）。例如：
#include <stdio.h>
int main() {
static int partialInitArray[5] = {1, 2};
for (int i = 0; i < 5; i++) {
printf("partialInitArray[%d] = %d\n", i, partialInitArray[i]);
}
return 0;
}
在这个例子中，partialInitArray 数组有5个元素，但初始化列表中只提供了2个值。因此，partialInitArray[0] 被初始化为1，partialInitArray[1] 被初始化为2，而 partialInitArray[2]、partialInitArray[3] 和 partialInitArray[4] 会被自动初始化为0。
这种部分初始化的方式在很多情况下非常有用，比如当数组的大部分元素初始值为0，只有少数元素有特定值时，可以减少初始化列表的长度，提高代码的简洁性。
省略数组大小初始化
在初始化静态数组时，如果使用初始化列表，还可以省略数组的大小。编译器会根据初始化列表中的元素个数来确定数组的大小。例如：
#include <stdio.h>
int main() {
static int omitSizeArray[] = {1, 3, 5, 7, 9};
for (int i = 0; i < sizeof(omitSizeArray) / sizeof(omitSizeArray[0]); i++) {
printf("omitSizeArray[%d] = %d\n", i, omitSizeArray[i]);
}
return 0;
}
在上述代码中，omitSizeArray 数组定义时没有指定大小，但通过初始化列表 {1, 3, 5, 7, 9}，编译器可以推断出该数组有5个元素。这里通过 sizeof(omitSizeArray) / sizeof(omitSizeArray[0]) 来获取数组的实际元素个数，这是一种常用的计算数组元素个数的方法。
这种方式在代码编写时更加灵活，特别是当你不确定数组具体元素个数，但又想通过初始化列表来定义数组时，编译器会自动帮你确定数组的大小。
自动数组初始化
完全初始化
自动数组（在函数内部定义，没有使用 static 关键字的数组）同样可以在定义时进行完全初始化，与静态数组类似。例如：
#include <stdio.h>
int main() {
int autoArray[4] = {2, 4, 6, 8};
for (int i = 0; i < 4; i++) {
printf("autoArray[%d] = %d\n", i, autoArray[i]);
}
return 0;
}
在 main 函数中，autoArray 是一个自动数组，被初始化为 {2, 4, 6, 8}。这种初始化方式与静态数组完全初始化类似，编译器会按照初始化列表的顺序为数组元素赋值。
部分初始化
自动数组也支持部分初始化。不过，与静态数组不同的是，未初始化的元素值是不确定的（垃圾值），而不是自动初始化为0。例如：
#include <stdio.h>
int main() {
int partialAutoArray[5] = {1, 2};
for (int i = 0; i < 5; i++) {
printf("partialAutoArray[%d] = %d\n", i, partialAutoArray[i]);
}
return 0;
}
在这个例子中，partialAutoArray 数组有5个元素，初始化列表只提供了2个值。partialAutoArray[0] 和 partialAutoArray[1] 分别被初始化为1和2，而 partialAutoArray[2]、partialAutoArray[3] 和 partialAutoArray[4] 的值是不确定的。在实际编程中，使用未初始化的自动数组元素可能会导致程序出现不可预测的行为，因此要特别小心。
省略数组大小初始化
自动数组在初始化时也可以省略数组大小，编译器同样会根据初始化列表中的元素个数来确定数组大小。例如：
#include <stdio.h>
int main() {
int omitAutoSizeArray[] = {100, 200, 300};
for (int i = 0; i < sizeof(omitAutoSizeArray) / sizeof(omitAutoSizeArray[0]); i++) {
printf("omitAutoSizeArray[%d] = %d\n", i, omitAutoSizeArray[i]);
}
return 0;
}
这里 omitAutoSizeArray 数组没有指定大小，编译器根据初始化列表 {100, 200, 300} 确定其大小为3。与静态数组省略大小初始化类似，这种方式增加了代码的灵活性。
字符数组初始化
逐个字符初始化
字符数组可以像普通数组一样逐个字符进行初始化。例如：
#include <stdio.h>
int main() {
char charArray1[5] = {'H', 'e', 'l', 'l', 'o'};
for (int i = 0; i < 5; i++) {
printf("%c", charArray1[i]);
}
printf("\n");
return 0;
}
在上述代码中，charArray1 数组被逐个字符初始化为 {'H', 'e', 'l', 'l', 'o'}。通过循环遍历，将每个字符打印出来，输出为 Hello。
使用字符串字面量初始化
更常见的是使用字符串字面量来初始化字符数组。例如：
#include <stdio.h>
int main() {
char charArray2[] = "Hello";
printf("%s\n", charArray2);
return 0;
}
这里 charArray2 数组使用字符串字面量 "Hello" 进行初始化。需要注意的是，字符串字面量在C语言中以 \0 作为结束符，因此虽然 "Hello" 看起来只有5个字符，但实际上在内存中占用6个字节，最后一个字节存储 \0。当使用 %s 格式化输出时，printf 函数会从数组的起始地址开始输出字符，直到遇到 \0 为止。
如果明确指定了字符数组的大小，并且该大小不足以容纳字符串字面量及其结束符 \0，会导致缓冲区溢出错误。例如：
#include <stdio.h>
int main() {
char charArray3[5] = "Hello"; // 错误，"Hello" 需要 6 个字节（包括 \0）
printf("%s\n", charArray3);
return 0;
}
在这个例子中，charArray3 只分配了5个字节的空间，而 "Hello" 连同结束符 \0 需要6个字节，这会导致缓冲区溢出，程序可能会出现不可预测的行为。
多维数组初始化
二维数组完全初始化
对于二维数组，可以进行完全初始化。例如：
#include <stdio.h>
int main() {
int twoDArray[2][3] = {
{1, 2, 3},
{4, 5, 6}
};
for (int i = 0; i < 2; i++) {
for (int j = 0; j < 3; j++) {
printf("twoDArray[%d][%d] = %d ", i, j, twoDArray[i][j]);
}
printf("\n");
}
return 0;
}
在上述代码中，twoDArray 是一个二维数组，twoDArray[2][3] 表示有2行3列。初始化列表使用大括号嵌套的方式，外层大括号包含每一行的初始化，内层大括号分别对应每一行的元素。通过两层循环遍历，将二维数组的每个元素打印出来。
二维数组部分初始化
二维数组也支持部分初始化。例如：
#include <stdio.h>
int main() {
int partialTwoDArray[2][3] = {
{1},
{4, 5}
};
for (int i = 0; i < 2; i++) {
for (int j = 0; j < 3; j++) {
printf("partialTwoDArray[%d][%d] = %d ", i, j, partialTwoDArray[i][j]);
}
printf("\n");
}
return 0;
}
这里 partialTwoDArray 进行了部分初始化。第一行只初始化了第一个元素为1，第二行初始化了前两个元素为4和5。未初始化的元素，对于静态二维数组会被初始化为0，对于自动二维数组，其值是不确定的（垃圾值）。
省略第一维大小初始化
在二维数组初始化时，可以省略第一维的大小，但第二维的大小必须明确指定。例如：
#include <stdio.h>
int main() {
int omitFirstDimArray[][3] = {
{1, 2, 3},
{4, 5, 6}
};
for (int i = 0; i < sizeof(omitFirstDimArray) / sizeof(omitFirstDimArray[0]); i++) {
for (int j = 0; j < 3; j++) {
printf("omitFirstDimArray[%d][%d] = %d ", i, j, omitFirstDimArray[i][j]);
}
printf("\n");
}
return 0;
}
在这个例子中，omitFirstDimArray 省略了第一维的大小。编译器会根据初始化列表中内层大括号的个数来确定第一维的大小。这里有两个内层大括号，所以第一维大小为2。通过 sizeof(omitFirstDimArray) / sizeof(omitFirstDimArray[0]) 可以获取第一维的实际大小。
动态数组初始化
使用 malloc 分配内存后初始化
在C语言中，可以使用 malloc 函数动态分配数组内存，然后对其进行初始化。例如：
#include <stdio.h>
#include <stdlib.h>
int main() {
int *dynamicArray;
int size = 5;
dynamicArray = (int *)malloc(size * sizeof(int));
if (dynamicArray == NULL) {
printf("Memory allocation failed\n");
return 1;
}
for (int i = 0; i < size; i++) {
dynamicArray[i] = i * 2;
}
for (int i = 0; i < size; i++) {
printf("dynamicArray[%d] = %d\n", i, dynamicArray[i]);
}
free(dynamicArray);
return 0;
}
在上述代码中，首先使用 malloc 函数分配了 size 个 int 类型大小的内存空间，并将返回的指针赋值给 dynamicArray。然后通过检查 dynamicArray 是否为 NULL 来判断内存分配是否成功。接着，通过循环对动态数组进行初始化，每个元素赋值为其索引值的两倍。最后，打印出数组的每个元素，并使用 free 函数释放动态分配的内存，以避免内存泄漏。
使用 calloc 分配内存并初始化
calloc 函数不仅可以分配内存，还会将分配的内存初始化为0。例如：
#include <stdio.h>
#include <stdlib.h>
int main() {
int *callocArray;
int size = 3;
callocArray = (int *)calloc(size, sizeof(int));
if (callocArray == NULL) {
printf("Memory allocation failed\n");
return 1;
}
for (int i = 0; i < size; i++) {
printf("callocArray[%d] = %d\n", i, callocArray[i]);
}
free(callocArray);
return 0;
}
在这个例子中，calloc 函数分配了 size 个 int 类型大小的内存空间，并将这些内存初始化为0。同样，先检查内存分配是否成功，然后打印出数组的每个元素，最后释放内存。
使用 realloc 调整动态数组大小并初始化
realloc 函数可以调整已经分配的动态内存的大小。如果新的大小比原来大，新增的内存部分会被初始化为不确定值（对于 realloc 扩展的自动内存）或者0（对于 realloc 扩展的静态内存）。例如：
#include <stdio.h>
#include <stdlib.h>
int main() {
int *reallocArray;
int oldSize = 3;
int newSize = 5;
reallocArray = (int *)malloc(oldSize * sizeof(int));
if (reallocArray == NULL) {
printf("Initial memory allocation failed\n");
return 1;
}
for (int i = 0; i < oldSize; i++) {
reallocArray[i] = i + 1;
}
reallocArray = (int *)realloc(reallocArray, newSize * sizeof(int));
if (reallocArray == NULL) {
printf("Reallocation failed\n");
free(reallocArray);
return 1;
}
for (int i = oldSize; i < newSize; i++) {
reallocArray[i] = i * 10;
}
for (int i = 0; i < newSize; i++) {
printf("reallocArray[%d] = %d\n", i, reallocArray[i]);
}
free(reallocArray);
return 0;
}
在上述代码中，首先使用 malloc 分配了 oldSize 大小的内存，并对其进行初始化。然后使用 realloc 将内存大小调整为 newSize。如果 realloc 成功，对新增的内存部分进行初始化，最后打印出整个数组的元素并释放内存。
数组初始化的注意事项
数组越界问题
在初始化数组时，要确保初始化列表中的元素个数不超过数组的大小。例如：
#include <stdio.h>
int main() {
int array[3] = {1, 2, 3, 4}; // 错误，初始化列表元素个数超过数组大小
return 0;
}
在这个例子中，array 数组大小为3，但初始化列表中有4个元素，这会导致编译错误或者未定义行为。
初始化顺序
数组初始化时，编译器会按照初始化列表的顺序依次为数组元素赋值。例如：
#include <stdio.h>
int main() {
int orderArray[3] = {5, 10, 15};
for (int i = 0; i < 3; i++) {
printf("orderArray[%d] = %d\n", i, orderArray[i]);
}
return 0;
}
这里 orderArray[0] 被初始化为5，orderArray[1] 被初始化为10，orderArray[2] 被初始化为15，按照初始化列表的顺序。
与指针的区别
虽然数组和指针在某些方面有相似之处，但在初始化时有着本质的区别。例如：
#include <stdio.h>
int main() {
int array[3] = {1, 2, 3};
int *ptr = &array[0];
// 数组名在多数情况下会被转换为指向其首元素的指针
// 但数组有自己的内存空间和大小
printf("Size of array: %zu\n", sizeof(array));
printf("Size of pointer: %zu\n", sizeof(ptr));
return 0;
}
在这个例子中，array 是一个数组，有自己的内存空间和大小，sizeof(array) 返回数组占用的总字节数。而 ptr 是一个指针，sizeof(ptr) 返回指针本身的大小（通常是4或8字节，取决于系统架构）。在初始化时，数组通过初始化列表进行元素赋值，而指针则是指向一个已存在的对象（这里是数组的首元素）。
初始化对性能的影响
对于大型数组，初始化方式可能会对性能产生一定影响。例如，静态数组的初始化在编译时完成，而动态数组的初始化在运行时进行。如果在程序启动时需要大量的初始化操作，静态数组可能会使程序的启动时间变长。但如果数组大小在运行时才能确定，动态数组则更为合适。
另外，对于自动数组，如果进行部分初始化，未初始化的元素在使用时可能会导致性能问题，因为读取未初始化的内存可能会触发缓存未命中等情况。在性能敏感的代码中，应尽量避免这种情况。
总结常见初始化方式及应用场景
静态数组初始化
- 完全初始化：适用于数组元素个数固定且每个元素都有明确初始值的情况，如全局配置数组等。
- 部分初始化：当数组大部分元素初始值为0或默认值，只有少数元素有特定值时，使用部分初始化可简化代码，如稀疏矩阵表示。
- 省略数组大小初始化：当不确定数组具体元素个数，但能通过初始化列表明确元素时，使用这种方式可让编译器自动确定数组大小，增加代码灵活性。
自动数组初始化
- 完全初始化：与静态数组完全初始化类似，适用于函数内部局部数组需要明确初始化的场景。
- 部分初始化：需谨慎使用，因为未初始化元素值不确定，可能导致程序出现不可预测行为。仅在明确知道后续会尽快为这些元素赋值时使用。
- 省略数组大小初始化：同静态数组省略大小初始化，适用于函数内部局部数组，根据初始化列表确定数组大小。
字符数组初始化
- 逐个字符初始化：适用于精确控制每个字符的场景，如自定义编码转换等。
- 使用字符串字面量初始化：是最常见的字符串初始化方式，适用于处理文本字符串，如打印输出、字符串比较等操作。
多维数组初始化
- 二维数组完全初始化：用于矩阵等数据结构，明确初始化每个元素，适用于矩阵乘法、图像处理等算法。
- 二维数组部分初始化：当矩阵大部分元素为0或默认值，只有少数非零元素时，可使用部分初始化减少代码量，如稀疏矩阵存储。
- 省略第一维大小初始化：适用于不确定矩阵行数，但列数固定且能通过初始化列表确定行数的场景。
动态数组初始化
- 使用 malloc 分配内存后初始化：适用于运行时才确定数组大小的场景，如根据用户输入动态分配数组。
- 使用 calloc 分配内存并初始化：需要分配内存并初始化为0时使用，如统计计数数组等。
- 使用 realloc 调整动态数组大小并初始化：当数组大小需要在运行时动态调整时使用，如动态增长的缓冲区。
通过了解C语言数组初始化的多种方法及其适用场景，可以编写出更高效、可靠的代码，避免常见的编程错误，提高程序的性能和可维护性。在实际编程中，应根据具体需求选择合适的初始化方式。