C 语言数组：连续内存中的批量数据管理

type arr_name[常量值];

int math[20];        /* 可以存放 20 个整数 */

char ch[8];          /* 可以存放 8 个字符 */
double score[10];    /* 可以存放 10 个双精度浮点数 */

/* 完全初始化：每个元素都给值 */
int arr[5] = {1, 2, 3, 4, 5};
 
/* 不完全初始化：只给第一个元素，其余自动为 0 */
int arr2[6] = {1};       /* arr2 = {1, 0, 0, 0, 0, 0} */
 
/* 全部初始化为 0 的常用写法 */
int arr3[10] = {0};      /* 所有元素都是 0 */
 
/* 初始化时可以不指定大小，编译器自动算 */
int arr4[] = {1, 2, 3};  /* 自动确定大小为 3 */

int arr[3] = {1, 2, 3, 4};  /* 错误：初始化项太多！ */

int arr1[10];    /* arr1 的类型是 int [10] */
int arr2[12];    /* arr2 的类型是 int [12] */
char ch[5];      /* ch   的类型是 char [5] */

#include <stdio.h>
 
int main()
{
    int arr[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
 
    printf("%d\n", arr[7]);   /* 访问下标 7，输出 8 */
    printf("%d\n", arr[3]);   /* 访问下标 3，输出 4 */
    /* arr[0]=1, arr[1]=2, ..., arr[9]=10 */
 
    return 0;
}

#include <stdio.h>
 
int main()
{
    int arr[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
    int i = 0;
 
    for (i = 0; i < 10; i++)       /* i 从 0 到 9 */
        printf("%d ", arr[i]);     /* 打印每个元素 */
 
    printf("\n");
    return 0;
}
/* 输出：1 2 3 4 5 6 7 8 9 10 */

#include <stdio.h>
 
int main()
{
    int arr[10] = {0};            /* 初始化为全 0 */
    int i = 0;
 
    printf("请输入 10 个整数：\n");
 
    for (i = 0; i < 10; i++)
        scanf("%d", &arr[i]);     /* &arr[i] 取每个元素的地址 */
 
    printf("你输入的是：");
    for (i = 0; i < 10; i++)
        printf("%d ", arr[i]);
 
    printf("\n");
    return 0;
}

#include <stdio.h>
 
int main()
{
    int arr[10] = {0};
    int i = 0;
 
    /* 越界访问：arr[10] 已经超出数组范围（有效下标 0~9） */
    arr[10] = 100;   /* 编译器可能不报错，但运行行为是未定义的！ */
    /* 可能：1. 程序正常运行（碰巧那块内存可写）
     *       2. 覆盖了相邻变量的值，导致莫名其妙的数据错乱
     *       3. 段错误 / 程序崩溃
     * 这次运行和下次运行的结果都可能不同！ */
 
    return 0;
}

#include <stdio.h>
 
int main()
{
    int arr[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
    int i = 0;
 
    /* 错误：i <= 10，当 i=10 时访问 arr[10]，越界！ */
    for (i = 0; i <= 10; i++)
        printf("%d ", arr[i]);
 
    return 0;
}

#include <stdio.h>
 
int main()
{
    int arr[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
    int i = 0;
 
    for (i = 0; i < 10; i++)
        printf("&arr[%d] = %p\n", i, &arr[i]);
    /* %p 是专门打印地址的占位符 */
 
    return 0;
}

#include <stdio.h>
 
int main()
{
    int arr[10] = {0};
 
    /* sizeof(arr) 是整个数组占的字节数：10 × 4 = 40 */
    printf("数组总大小：%zd 字节\n", sizeof(arr));
 
    /* sizeof(arr[0]) 是一个元素占的字节数：4 */
    printf("一个元素大小：%zd 字节\n", sizeof(arr[0]));
 
    /* 元素个数 = 总大小 / 单个大小 */
    int sz = sizeof(arr) / sizeof(arr[0]);
    printf("元素个数：%d\n", sz);     /* 10 */
 
    return 0;
}

#include <stdio.h>
 
int main()
{
    int arr[] = {3, 1, 4, 1, 5, 9, 2, 6};  /* 随便多少个元素 */
    int sz = sizeof(arr) / sizeof(arr[0]);   /* 自动算 */
    int i = 0;
 
    for (i = 0; i < sz; i++)
        printf("%d ", arr[i]);
 
    printf("\n数组共 %d 个元素\n", sz);
    return 0;
}

#include <stdio.h>
 
int main()
{
    int arr[] = {1, 2, 3, 4, 5};
    int sz = sizeof(arr) / sizeof(arr[0]);
    int i = 0;
 
    /* 练习1：把所有元素翻倍 */
    for (i = 0; i < sz; i++)
        arr[i] *= 2;              /* arr = {2, 4, 6, 8, 10} */
 
    /* 练习2：把元素逆置（第一个和最后一个交换...） */
    int left = 0, right = sz - 1;
    while (left < right)
    {
        int temp = arr[left];
        arr[left] = arr[right];
        arr[right] = temp;
        left++;
        right--;
    }
    /* arr = {10, 8, 6, 4, 2} */
 
    /* 练习3：找到最大值及其下标 */
    int max = arr[0];
    int maxIdx = 0;
    for (i = 1; i < sz; i++)
    {
        if (arr[i] > max)
        {
            max = arr[i];
            maxIdx = i;
        }
    }
    printf("最大值 = %d，下标 = %d\n", max, maxIdx);
 
    /* 打印验证 */
    for (i = 0; i < sz; i++)
        printf("%d ", arr[i]);
    printf("\n");
 
    return 0;
}

#include <stdio.h>
 
int main()
{
    int arr[] = {9, 5, 2, 7, 1, 8, 3, 6, 4, 0};
    int sz = sizeof(arr) / sizeof(arr[0]);
    int i = 0, j = 0;
 
    /* 冒泡排序：外层控制轮数（sz-1 轮），内层做相邻比较交换 */
    for (i = 0; i < sz - 1; i++)
    {
        for (j = 0; j < sz - 1 - i; j++)  /* 每轮少比较一个（末尾已排好） */
        {
            if (arr[j] > arr[j + 1])      /* 前一个比后一个大 → 交换 */
            {
                int temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
    }
 
    /* 打印排序结果 */
    for (i = 0; i < sz; i++)
        printf("%d ", arr[i]);
    printf("\n");
    /* 输出：0 1 2 3 4 5 6 7 8 9 */
 
    return 0;
}

type arr_name[常量值1][常量值2];

int arr[3][5];       /* 3 行 5 列，共 15 个 int 元素 */
double data[2][8];   /* 2 行 8 列，共 16 个 double 元素 */

/* 不完全初始化：给前两个，其余自动为 0 */
int arr1[3][5] = {1, 2};
 
/* 全部初始化为 0（最实用的写法） */
int arr2[3][5] = {0};
 
/* 完全初始化：按行顺序填充 */
int arr3[3][5] = {1,2,3,4,5, 2,3,4,5,6, 3,4,5,6,7};
 
/* 按行初始化：每组大括号对应一行 */
int arr4[3][5] = {{1,2}, {3,4}, {5,6}};
/* 第一行：1,2,0,0,0
 * 第二行：3,4,0,0,0
 * 第三行：5,6,0,0,0 */
 
/* 初始化时可以省略行数，但不能省略列数 */
int arr5[][5] = {1, 2, 3};            /* 自动算出行数为 1 */
int arr6[][5] = {1,2,3,4,5,6,7};      /* 自动算出行数为 2 */
int arr7[][5] = {{1,2}, {3,4}, {5,6}};/* 行数为 3 */

#include <stdio.h>
 
int main()
{
    /* 3 行 5 列的数组 */
    int arr[3][5] = {
        {1, 2, 3, 4, 5},      /* 第 0 行 */
        {2, 3, 4, 5, 6},      /* 第 1 行 */
        {3, 4, 5, 6, 7}       /* 第 2 行 */
    };
 
    printf("%d\n", arr[2][4]);  /* 第 2 行第 4 列 → 7 */
    printf("%d\n", arr[0][0]);  /* 第 0 行第 0 列 → 1 */
 
    return 0;
}

#include <stdio.h>
 
int main()
{
    int arr[3][5] = {
        {1, 2, 3, 4, 5},
        {2, 3, 4, 5, 6},
        {3, 4, 5, 6, 7}
    };
 
    int i = 0, j = 0;
 
    /* 输入 */
    printf("请输入 15 个整数：\n");
    for (i = 0; i < 3; i++)           /* 外层：遍历每一行 */
    {
        for (j = 0; j < 5; j++)       /* 内层：遍历当前行的每一列 */
        {
            scanf("%d", &arr[i][j]);
        }
    }
 
    /* 输出（按矩阵格式） */
    printf("二维数组内容：\n");
    for (i = 0; i < 3; i++)
    {
        for (j = 0; j < 5; j++)
        {
            printf("%2d ", arr[i][j]); /* %2d 对齐显示 */
        }
        printf("\n");                  /* 每行结束换行 */
    }
 
    return 0;
}

#include <stdio.h>
 
int main()
{
    int arr[3][5] = {0};
    int i = 0, j = 0;
 
    for (i = 0; i < 3; i++)
    {
        for (j = 0; j < 5; j++)
        {
            printf("&arr[%d][%d] = %p\n", i, j, &arr[i][j]);
        }
    }
 
    return 0;
}

int arr1[10];
int arr2[3 + 5];
int arr3[] = {1, 2, 3};

#include <stdio.h>
 
int main()
{
    int n = 0;
    scanf("%d", &n);      /* 运行时才知道 n 是多少 */
 
    int arr[n];            /* C99 VLA：数组大小在运行时确定 */
 
    int i = 0;
    for (i = 0; i < n; i++)
    {
        scanf("%d", &arr[i]);
    }
 
    for (i = 0; i < n; i++)
    {
        printf("%d ", arr[i]);
    }
    printf("\n");
 
    return 0;
}

#include <stdio.h>
#include <string.h>    /* strlen() */
#include <windows.h>   /* Sleep()，Windows 专用 */
 
int main()
{
    /* 目标字符串 */
    char arr1[] = "welcome to bit...";
 
    /* 遮盖用的字符串，长度和目标相同 */
    char arr2[] = "#################";
 
    int left = 0;                          /* 左端下标 */
    int right = strlen(arr1) - 1;          /* 右端下标 */
 
    printf("%s\n", arr2);                  /* 初始：全是 # */
 
    while (left <= right)                  /* 左右指针还未相遇 */
    {
        Sleep(1000);                       /* 暂停 1000 毫秒（1 秒） */
        arr2[left] = arr1[left];           /* 左端字符逐渐显现 */
        arr2[right] = arr1[right];         /* 右端字符逐渐显现 */
        left++;                            /* 左端向右移动 */
        right--;                           /* 右端向左移动 */
        printf("%s\n", arr2);              /* 打印当前效果 */
    }
 
    return 0;
}
/* 运行效果（每行间隔 1 秒）：
 * #################
 * w###############.
 * we#############..
 * wel###########...
 * welc#########t...
 * ...最终变成：welcome to bit...
 */

#include <stdio.h>
 
int main()
{
    int arr[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};  /* 升序数组 */
    int sz = sizeof(arr) / sizeof(arr[0]);          /* 元素个数 */
 
    int left = 0;                                    /* 查找区间左边界 */
    int right = sz - 1;                              /* 查找区间右边界 */
    int key = 7;                                     /* 要找的数字 */
    int mid = 0;                                     /* 中间位置 */
    int find = 0;                                    /* 0=没找到，1=找到了 */
 
    while (left <= right)                            /* 区间有效 */
    {
        mid = left + (right - left) / 2;             /* 计算中间位置 */
 
        if (arr[mid] > key)                          /* 中间值太大 */
            right = mid - 1;                         /* 去左半边找 */
        else if (arr[mid] < key)                     /* 中间值太小 */
            left = mid + 1;                          /* 去右半边找 */
        else
        {
            find = 1;                                /* 找到了 */
            break;                                   /* 退出循环 */
        }
    }
 
    if (find == 1)
        printf("找到了！%d 的下标是 %d\n", key, mid);
    else
        printf("找不到 %d\n", key);
 
    return 0;
}
/* 输出：找到了！7 的下标是 6 */

#include <stdio.h>
 
int main()
{
    /* 输入 10 个整数，先统计正数个数，再逆序打印 */
    int arr[10] = {0};
    int i = 0;
    int positive = 0;
 
    printf("请输入 10 个整数：\n");
    for (i = 0; i < 10; i++)
    {
        scanf("%d", &arr[i]);
        if (arr[i] > 0)
            positive++;          /* 边输入边统计，省一次循环 */
    }
 
    printf("正数个数：%d\n", positive);
    printf("逆序输出：");
    for (i = 9; i >= 0; i--)     /* 下标从大到小遍历 */
    {
        printf("%d ", arr[i]);
    }
    printf("\n");
 
    return 0;
}

int *arr = (int*)malloc(n * sizeof(int));  /* n 在运行时才确定大小 */
/* 之后可以像数组一样用 arr[0] ~ arr[n-1] ... */
free(arr);                                 /* 用完一定要释放 */