本实验通过一系列递进式编程任务，系统性地揭示C语言中一维与二维数组的内存组织规律、指针与地址的本质关系，以及字符串操作的核心技巧。

数组内存结构分析

在C语言中，数组名本质上是首元素的地址常量。对于一维数组 int arr[4]，sizeof(arr) 返回整个数组所占字节数（16字节），而 arr 与 &arr[0] 数值相等但类型不同：前者是 int*，后者是 int*；对 char ch[4] 同理，sizeof(ch) 为4字节。这印证了数组存储的连续性与类型决定单元素大小的基本原理。

二维数组则体现"数组的数组"语义。以 int matrix[2][4] 为例，sizeof(matrix) 为32字节（2×4×4），matrix、matrix[0]、matrix[1] 三者地址数值依次相差16字节（即一行所占空间），表明行间连续存储。而 matrix[0] 与 &matrix[0][0] 地址相同，证实行首地址即该行一维数组的起始地址。

字符串交换的两种范式

字符串交换需区分存储模型：
- 使用两个独立的一维字符数组时，交换本质是内存块内容复制，通过临时缓冲区调用 strcpy() 实现；
- 使用二维字符数组 char strs[2][N] 时，strs[0] 和 strs[1] 是两个独立的、可修改的字符数组首地址，仍需逐字节复制，而非交换指针——因数组名不可赋值。

健壮的单词计数器

基础版本仅以空格为分界符，易受标点干扰。改进方案需识别非字母数字字符作为单词边界。以下实现使用 isalnum() 函数（需包含 <ctype.h>）提升鲁棒性：

#include <stdio.h>
#include <ctype.h>

int count_words(const char *s) {
    int count = 0;
    int in_word = 0;
    
    while (*s) {
        if (isalnum((unsigned char)*s)) {
            if (!in_word) {
                count++;
                in_word = 1;
            }
        } else {
            in_word = 0;
        }
        s++;
    }
    return count;
}

最长单词提取算法

该任务要求在单次扫描中定位最长单词。核心策略是维护当前单词长度 curr_len 与全局最大长度 max_len，同时记录最长单词的结束索引 end_pos。当遇到空白或字符串结尾时，更新最大值并重置当前长度。最终通过 end_pos - max_len 定位起始位置，安全输出子串。

进制转换工具函数

通用进制转换函数 convert_base(int num, int base) 采用短除法逆序收集余数。关键点在于：当余数 ≥10 时，映射为 'A'–'F'；结果需反向打印。以下为重构后的清晰实现：

void convert_base(int num, int base) {
    if (num == 0) {
        printf("0");
        return;
    }
    
    char digits[N];
    int idx = 0;
    int n = num < 0 ? -num : num;
    
    do {
        int r = n % base;
        digits[idx++] = r < 10 ? '0' + r : 'A' + r - 10;
        n /= base;
    } while (n > 0);
    
    if (num < 0) putchar('-');
    for (int i = idx - 1; i >= 0; --i) {
        putchar(digits[i]);
    }
}

排序算法的正确实现

冒泡排序需严格遵循两层循环逻辑：外层控制轮数，内层执行相邻比较与交换。常见错误包括混淆索引变量（如 str[i] 误写为 str[j]）、未正确终止条件。修正后的字符串排序如下：

void bubble_sort_strings(char str[][M], int n) {
    char temp[M];
    for (int i = 0; i < n - 1; i++) {
        for (int j = 0; j < n - 1 - i; j++) {
            if (strcmp(str[j], str[j + 1]) > 0) {
                strcpy(temp, str[j]);
                strcpy(str[j], str[j + 1]);
                strcpy(str[j + 1], temp);
            }
        }
    }
}

矩阵顺时针旋转

将 n×n 矩阵向右旋转90度，等价于转置后按行反转。高效原地实现可避免额外空间：

void rotate_right_90(int mat[][N], int n) {
    // Step 1: Transpose
    for (int i = 0; i < n; i++) {
        for (int j = i + 1; j < n; j++) {
            int t = mat[i][j];
            mat[i][j] = mat[j][i];
            mat[j][i] = t;
        }
    }
    // Step 2: Reverse each row
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n / 2; j++) {
            int t = mat[i][j];
            mat[i][j] = mat[i][n - 1 - j];
            mat[i][n - 1 - j] = t;
        }
    }
}

幻方生成器

奇数阶幻方采用"Siamese方法"：从第一行中间开始，按右上方向填充，越界则绕回，遇已填则下移一格。以下为修正后的标准实现：

void generate_magic_square(int n, int square[][100]) {
    for (int i = 0; i < n; i++)
        for (int j = 0; j < n; j++)
            square[i][j] = 0;
    
    int row = 0, col = n / 2;
    for (int num = 1; num <= n * n; num++) {
        square[row][col] = num;
        int next_row = (row - 1 + n) % n;
        int next_col = (col + 1) % n;
        if (square[next_row][next_col] != 0) {
            row = (row + 1) % n;
        } else {
            row = next_row;
            col = next_col;
        }
    }
}