4.3 for 循环

🎯 深度理论解析

4.3.1 for循环的计算理论与数学基础

for循环是确定性迭代的典范，其理论模型基于算术级数和组合数学。在程序语义学中，for循环可视为有界迭代的语法糖，具有可预测的迭代次数和明确的终止条件。

形式化定义

在迪克斯特拉最弱前置条件语义中，for循环可表示为：

for (init; condition; update) S

等价于：

init;
while (condition) {
    S;
    update;
}

4.3.2 for循环的语法语义深度剖析

标准语法结构

for (初始化表达式; 循环条件表达式; 更新表达式) {
    // 循环体 - 可执行语句序列
}

执行语义模型

1. 初始化阶段：执行初始化表达式（仅一次）
2. 条件评估阶段：计算循环条件表达式
3. 迭代决策阶段：若结果为true，执行循环体；否则终止
4. 更新阶段：执行更新表达式，返回步骤2
5. 关键特性：明确的循环控制、可预测的迭代次数

🔬 核心技术实现

4.3.3 基础for循环模式

模式1：经典数值迭代

#include <stdio.h>
#include <math.h>

/**
 * 🎯 经典数值迭代模式
 * 特征：明确的起始值、终止条件、步进策略
 * 应用：数值计算、序列生成、数组遍历
 */
void classical_numeric_iteration() {
    printf("🚀 经典数值迭代模式演示\n");
    printf("======================\n");
    
    // 正向递增迭代
    printf("1. 正向递增迭代 (1-10):\n");
    for (int i = 1; i <= 10; i++) {
        printf("%2d ", i);
    }
    printf("\n\n");
    
    // 反向递减迭代
    printf("2. 反向递减迭代 (10-1):\n");
    for (int i = 10; i >= 1; i--) {
        printf("%2d ", i);
    }
    printf("\n\n");
    
    // 自定义步长迭代
    printf("3. 自定义步长迭代 (0-20, 步长3):\n");
    for (int i = 0; i <= 20; i += 3) {
        printf("%2d ", i);
    }
    printf("\n\n");
    
    // 浮点数迭代（注意精度问题）
    printf("4. 浮点数迭代 (0.0-1.0, 步长0.1):\n");
    for (double x = 0.0; x <= 1.0 + 1e-9; x += 0.1) {
        printf("%.1f ", x);
    }
    printf("\n\n");
    
    // 数学函数迭代
    printf("5. 数学函数迭代 (x, x², √x):\n");
    printf("%4s %4s %6s %6s\n", "x", "x²", "√x", "log(x)");
    printf("---- ---- ------ ------\n");
    
    for (int x = 1; x <= 5; x++) {
        printf("%4d %4d %6.2f %6.2f\n", 
               x, x*x, sqrt(x), log(x));
    }
}

模式2：数组与集合遍历

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

/**
 * 🎯 数组与集合遍历模式
 * 特征：基于索引的集合访问，边界明确的迭代
 * 应用：数据处理、算法实现、集合操作
 */
void array_collection_traversal() {
    printf("📊 数组与集合遍历模式演示\n");
    printf("========================\n");
    
    // 一维数组遍历
    int numbers[] = {23, 45, 67, 12, 89, 34, 56, 78, 90, 15};
    int size = sizeof(numbers) / sizeof(numbers[0]);
    
    printf("1. 一维数组遍历:\n");
    printf("数组: ");
    for (int i = 0; i < size; i++) {
        printf("%d ", numbers[i]);
    }
    printf("\n");
    
    // 统计计算
    int sum = 0, max = numbers[0], min = numbers[0];
    for (int i = 0; i < size; i++) {
        sum += numbers[i];
        if (numbers[i] > max) max = numbers[i];
        if (numbers[i] < min) min = numbers[i];
    }
    printf("统计: 总和=%d, 最大值=%d, 最小值=%d, 平均值=%.2f\n\n", 
           sum, max, min, (double)sum / size);
    
    // 字符串遍历
    char text[] = "Hello, World!";
    int length = strlen(text);
    
    printf("2. 字符串遍历:\n");
    printf("原文: %s\n", text);
    printf("字符分析: ");
    for (int i = 0; i < length; i++) {
        printf("[%c:%d] ", text[i], text[i]);
    }
    printf("\n\n");
    
    // 二维数组遍历
    int matrix[3][4] = {
        {1, 2, 3, 4},
        {5, 6, 7, 8},
        {9, 10, 11, 12}
    };
    
    printf("3. 二维数组遍历:\n");
    for (int row = 0; row < 3; row++) {
        printf("行 %d: ", row);
        for (int col = 0; col < 4; col++) {
            printf("%3d", matrix[row][col]);
        }
        printf("\n");
    }
    
    // 矩阵运算：行求和
    printf("\n4. 矩阵行统计:\n");
    for (int row = 0; row < 3; row++) {
        int row_sum = 0;
        for (int col = 0; col < 4; col++) {
            row_sum += matrix[row][col];
        }
        printf("行 %d 求和: %d\n", row, row_sum);
    }
}

模式3：复杂条件迭代

#include <stdio.h>
#include <stdbool.h>

/**
 * 🎯 复杂条件迭代模式
 * 特征：多变量控制、复合条件、复杂更新逻辑
 * 应用：复杂算法、状态转换、多序列处理
 */
void complex_condition_iteration() {
    printf("🎛️ 复杂条件迭代模式演示\n");
    printf("======================\n");
    
    // 多变量控制迭代
    printf("1. 多变量控制迭代:\n");
    printf("斐波那契数列 (前20项):\n");
    
    long long a = 0, b = 1;
    printf("%lld %lld ", a, b);
    
    for (int i = 3, temp; i <= 20; i++) {
        temp = a + b;
        a = b;
        b = temp;
        printf("%lld ", b);
    }
    printf("\n\n");
    
    // 复合条件迭代
    printf("2. 复合条件迭代:\n");
    printf("寻找1-100中能被3或5整除但不能被15整除的数:\n");
    
    int count = 0;
    for (int i = 1; i <= 100; i++) {
        if ((i % 3 == 0 || i % 5 == 0) && i % 15 != 0) {
            printf("%3d", i);
            count++;
            if (count % 10 == 0) printf("\n");
        }
    }
    printf("\n总计: %d 个数字\n\n", count);
    
    // 复杂更新逻辑
    printf("3. 复杂更新逻辑:\n");
    printf("Collatz序列 (从27开始):\n");
    
    int n = 27;
    int steps = 0;
    printf("%d", n);
    
    for (; n != 1; steps++) {
        if (n % 2 == 0) {
            n = n / 2;
        } else {
            n = 3 * n + 1;
        }
        printf(" → %d", n);
        
        if ((steps + 1) % 10 == 0) printf("\n");
    }
    printf("\n总步数: %d\n\n", steps);
    
    // 多序列并行迭代
    printf("4. 多序列并行迭代:\n");
    int seq1[] = {1, 3, 5, 7, 9};
    int seq2[] = {2, 4, 6, 8, 10};
    int seq_size = 5;
    
    printf("序列1: ");
    for (int i = 0; i < seq_size; i++) printf("%d ", seq1[i]);
    printf("\n序列2: ");
    for (int i = 0; i < seq_size; i++) printf("%d ", seq2[i]);
    
    printf("\n交替合并: ");
    for (int i = 0; i < seq_size; i++) {
        printf("%d %d ", seq1[i], seq2[i]);
    }
    printf("\n");
}

4.3.4 高级for循环技术

技术1：位运算与集合枚举

#include <stdio.h>

/**
 * 🔢 位运算与集合枚举技术
 * 特征：利用位掩码表示集合，高效枚举子集
 * 应用：组合数学、状态压缩、算法优化
 */
void bit_manipulation_enumeration() {
    printf("🔢 位运算与集合枚举技术\n");
    printf("======================\n");
    
    // 子集枚举
    printf("1. 集合子集枚举:\n");
    char set[] = {'A', 'B', 'C', 'D'};
    int n = 4;  // 集合大小
    int total_subsets = 1 << n;  // 2^n
    
    printf("集合: {A, B, C, D}\n");
    printf("所有子集 (%d个):\n", total_subsets);
    
    for (int mask = 0; mask < total_subsets; mask++) {
        printf("{");
        int first = 1;
        for (int i = 0; i < n; i++) {
            if (mask & (1 << i)) {
                if (!first) printf(", ");
                printf("%c", set[i]);
                first = 0;
            }
        }
        printf("}\n");
    }
    printf("\n");
    
    // 组合枚举 C(n, k)
    printf("2. 组合枚举 C(5, 3):\n");
    n = 5;
    int k = 3;
    
    // 使用位运算技巧生成组合
    int combination = (1 << k) - 1;
    int count = 0;
    
    while (combination < (1 << n)) {
        printf("组合 %d: {", ++count);
        int first = 1;
        for (int i = 0; i < n; i++) {
            if (combination & (1 << i)) {
                if (!first) printf(", ");
                printf("%d", i + 1);
                first = 0;
            }
        }
        printf("}\n");
        
        // 生成下一个组合（位运算技巧）
        int x = combination & -combination;
        int y = combination + x;
        combination = (((combination & ~y) / x) >> 1) | y;
    }
    printf("总计: %d 个组合\n\n", count);
    
    // 位操作迭代
    printf("3. 位操作迭代技巧:\n");
    unsigned int bits = 0b11010101;  // 213
    printf("原始数值: %u (二进制: ", bits);
    
    for (int i = 31; i >= 0; i--) {
        printf("%d", (bits >> i) & 1);
        if (i % 8 == 0 && i != 0) printf(" ");
    }
    printf(")\n");
    
    printf("置位统计: ");
    int bit_count = 0;
    for (unsigned int temp = bits; temp; temp >>= 1) {
        bit_count += temp & 1;
    }
    printf("%d 个1\n", bit_count);
    
    printf("位反转: ");
    unsigned int reversed = 0;
    for (int i = 0; i < 32; i++) {
        reversed = (reversed << 1) | ((bits >> i) & 1);
    }
    printf("%u\n", reversed);
}

技术2：性能优化循环模式

#include <stdio.h>
#include <time.h>

/**
 * ⚡ 性能优化循环模式
 * 特征：循环展开、缓存友好、减少分支预测失败
 * 应用：高性能计算、数值算法、系统编程
 */
void performance_optimized_loops() {
    printf("⚡ 性能优化循环模式\n");
    printf("==================\n");
    
    const int SIZE = 1000000;
    int data[SIZE];
    
    // 初始化测试数据
    for (int i = 0; i < SIZE; i++) {
        data[i] = i % 100;
    }
    
    // 1. 循环展开技术
    printf("1. 循环展开技术对比:\n");
    
    clock_t start, end;
    long long sum1 = 0, sum2 = 0;
    
    // 标准循环
    start = clock();
    for (int i = 0; i < SIZE; i++) {
        sum1 += data[i];
    }
    end = clock();
    double time1 = ((double)(end - start)) / CLOCKS_PER_SEC;
    
    // 循环展开（4次）
    start = clock();
    int i;
    for (i = 0; i < SIZE - 3; i += 4) {
        sum2 += data[i];
        sum2 += data[i + 1];
        sum2 += data[i + 2];
        sum2 += data[i + 3];
    }
    // 处理剩余元素
    for (; i < SIZE; i++) {
        sum2 += data[i];
    }
    end = clock();
    double time2 = ((double)(end - start)) / CLOCKS_PER_SEC;
    
    printf("标准循环: 总和=%lld, 时间=%.6f秒\n", sum1, time1);
    printf("循环展开: 总和=%lld, 时间=%.6f秒\n", sum2, time2);
    printf("性能提升: %.2f%%\n\n", (time1 - time2) / time1 * 100);
    
    // 2. 缓存友好访问模式
    printf("2. 缓存友好访问模式:\n");
    
    int matrix[1000][1000];
    
    // 行优先访问（缓存友好）
    start = clock();
    long long row_major_sum = 0;
    for (int row = 0; row < 1000; row++) {
        for (int col = 0; col < 1000; col++) {
            row_major_sum += matrix[row][col];
        }
    }
    end = clock();
    double row_time = ((double)(end - start)) / CLOCKS_PER_SEC;
    
    // 列优先访问（缓存不友好）
    start = clock();
    long long col_major_sum = 0;
    for (int col = 0; col < 1000; col++) {
        for (int row = 0; row < 1000; row++) {
            col_major_sum += matrix[row][col];
        }
    }
    end = clock();
    double col_time = ((double)(end - start)) / CLOCKS_PER_SEC;
    
    printf("行优先访问: 时间=%.6f秒\n", row_time);
    printf("列优先访问: 时间=%.6f秒\n", col_time);
    printf("性能差异: %.2f倍\n\n", col_time / row_time);
    
    // 3. 减少分支预测失败
    printf("3. 分支预测优化:\n");
    
    int sorted_data[SIZE];
    int unsorted_data[SIZE];
    
    // 初始化排序和未排序数据
    for (int i = 0; i < SIZE; i++) {
        sorted_data[i] = i;           // 已排序
        unsorted_data[i] = rand() % SIZE;  // 未排序
    }
    
    // 在已排序数据上计数（分支预测成功）
    start = clock();
    int count_sorted = 0;
    for (int i = 0; i < SIZE; i++) {
        if (sorted_data[i] < SIZE / 2) {
            count_sorted++;
        }
    }
    end = clock();
    double sorted_time = ((double)(end - start)) / CLOCKS_PER_SEC;
    
    // 在未排序数据上计数（分支预测失败）
    start = clock();
    int count_unsorted = 0;
    for (int i = 0; i < SIZE; i++) {
        if (unsorted_data[i] < SIZE / 2) {
            count_unsorted++;
        }
    }
    end = clock();
    double unsorted_time = ((double)(end - start)) / CLOCKS_PER_SEC;
    
    printf("已排序数据计数: 时间=%.6f秒\n", sorted_time);
    printf("未排序数据计数: 时间=%.6f秒\n", unsorted_time);
    printf("分支预测影响: %.2f倍\n", unsorted_time / sorted_time);
}

技术3：算法模式实现

#include <stdio.h>
#include <stdbool.h>

/**
 * 🧮 算法模式实现技术
 * 特征：经典算法的for循环实现，展示算法思维
 * 应用：算法学习、竞赛编程、系统优化
 */
void algorithmic_patterns() {
    printf("🧮 算法模式实现技术\n");
    printf("==================\n");
    
    // 1. 素数筛法（埃拉托斯特尼筛法）
    printf("1. 素数筛法 (1-100的素数):\n");
    
    const int LIMIT = 100;
    bool is_prime[LIMIT + 1];
    
    // 初始化标记数组
    for (int i = 2; i <= LIMIT; i++) {
        is_prime[i] = true;
    }
    
    // 筛法核心算法
    for (int p = 2; p * p <= LIMIT; p++) {
        if (is_prime[p]) {
            for (int i = p * p; i <= LIMIT; i += p) {
                is_prime[i] = false;
            }
        }
    }
    
    // 输出素数
    int prime_count = 0;
    for (int i = 2; i <= LIMIT; i++) {
        if (is_prime[i]) {
            printf("%3d", i);
            prime_count++;
            if (prime_count % 10 == 0) printf("\n");
        }
    }
    printf("\n总计: %d 个素数\n\n", prime_count);
    
    // 2. 动态规划：斐波那契数列
    printf("2. 动态规划斐波那契数列:\n");
    
    int n = 20;
    long long fib[100] = {0};
    fib[1] = 1;
    
    printf("斐波那契数列 (前%d项):\n", n);
    printf("F(0)=%lld, F(1)=%lld", fib[0], fib[1]);
    
    for (int i = 2; i <= n; i++) {
        fib[i] = fib[i-1] + fib[i-2];
        printf(", F(%d)=%lld", i, fib[i]);
        
        if ((i - 1) % 5 == 0) printf("\n");
    }
    printf("\n\n");
    
    // 3. 搜索算法：二分查找
    printf("3. 二分查找算法:\n");
    
    int sorted_array[] = {2, 5, 8, 12, 16, 23, 38, 45, 67, 89};
    int array_size = sizeof(sorted_array) / sizeof(sorted_array[0]);
    int target = 23;
    
    printf("有序数组: ");
    for (int i = 0; i < array_size; i++) {
        printf("%d ", sorted_array[i]);
    }
    printf("\n查找目标: %d\n", target);
    
    int left = 0, right = array_size - 1;
    int result = -1;
    
    for (; left <= right; ) {
        int mid = left + (right - left) / 2;
        
        printf("搜索区间: [%d, %d], 中间点: %d\n", left, right, mid);
        
        if (sorted_array[mid] == target) {
            result = mid;
            break;
        } else if (sorted_array[mid] < target) {
            left = mid + 1;
        } else {
            right = mid - 1;
        }
    }
    
    if (result != -1) {
        printf("找到目标，索引: %d\n", result);
    } else {
        printf("未找到目标\n");
    }
    printf("\n");
    
    // 4. 排序算法：选择排序
    printf("4. 选择排序算法:\n");
    
    int to_sort[] = {64, 34, 25, 12, 22, 11, 90};
    int sort_size = sizeof(to_sort) / sizeof(to_sort[0]);
    
    printf("排序前: ");
    for (int i = 0; i < sort_size; i++) {
        printf("%d ", to_sort[i]);
    }
    printf("\n");
    
    // 选择排序实现
    for (int i = 0; i < sort_size - 1; i++) {
        int min_index = i;
        for (int j = i + 1; j < sort_size; j++) {
            if (to_sort[j] < to_sort[min_index]) {
                min_index = j;
            }
        }
        
        // 交换元素
        if (min_index != i) {
            int temp = to_sort[i];
            to_sort[i] = to_sort[min_index];
            to_sort[min_index] = temp;
        }
        
        printf("第%d轮: ", i + 1);
        for (int k = 0; k < sort_size; k++) {
            printf("%d ", to_sort[k]);
        }
        printf("\n");
    }
    
    printf("排序后: ");
    for (int i = 0; i < sort_size; i++) {
        printf("%d ", to_sort[i]);
    }
    printf("\n");
}

🛠️ 实战项目案例

项目1：科学计算与数据分析引擎

#include <stdio.h>
#include <math.h>
#include <stdbool.h>

/**
 * 📈 科学计算与数据分析引擎
 * 功能：数值积分、统计分析、数据变换、曲线拟合
 */
void scientific_computing_engine() {
    printf("📈 科学计算与数据分析引擎\n");
    printf("========================\n");
    
    // 1. 数值积分：梯形法
    printf("1. 数值积分 - 梯形法\n");
    
    double a = 0.0, b = 3.1415926535;  // 积分区间 [0, π]
    int n = 1000;                       // 分割数
    double h = (b - a) / n;             // 步长
    
    // 计算 ∫sin(x)dx 从 0 到 π，理论值应为 2.0
    double integral = 0.0;
    
    // 梯形法公式: h/2 * [f(x0) + 2f(x1) + ... + 2f(x_{n-1}) + f(xn)]
    integral = sin(a) + sin(b);  // 首尾项
    
    for (int i = 1; i < n; i++) {
        double x = a + i * h;
        integral += 2 * sin(x);
    }
    
    integral *= h / 2;
    
    printf("函数: sin(x)\n");
    printf("积分区间: [0, π]\n");
    printf("分割数: %d\n", n);
    printf("数值结果: %.10f\n", integral);
    printf("理论值: 2.0000000000\n");
    printf("绝对误差: %.10f\n\n", fabs(integral - 2.0));
    
    // 2. 统计分析：直方图生成
    printf("2. 统计分析 - 直方图\n");
    
    int data[] = {23, 45, 67, 12, 89, 34, 56, 78, 90, 15,
                  42, 63, 27, 81, 39, 54, 72, 18, 95, 61};
    int data_size = sizeof(data) / sizeof(data[0]);
    
    // 计算统计量
    int data_min = data[0], data_max = data[0];
    double data_sum = 0.0;
    
    for (int i = 0; i < data_size; i++) {
        if (data[i] < data_min) data_min = data[i];
        if (data[i] > data_max) data_max = data[i];
        data_sum += data[i];
    }
    double data_mean = data_sum / data_size;
    
    // 计算方差和标准差
    double variance = 0.0;
    for (int i = 0; i < data_size; i++) {
        variance += (data[i] - data_mean) * (data[i] - data_mean);
    }
    variance /= data_size;
    double std_dev = sqrt(variance);
    
    printf("数据集: ");
    for (int i = 0; i < data_size; i++) {
        printf("%d ", data[i]);
    }
    printf("\n");
    
    printf("样本数: %d\n", data_size);
    printf("最小值: %d, 最大值: %d\n", data_min, data_max);
    printf("平均值: %.2f\n", data_mean);
    printf("标准差: %.2f\n", std_dev);
    
    // 生成直方图
    printf("\n直方图 (区间大小=10):\n");
    int bins[10] = {0};  // 10个区间
    
    for (int i = 0; i < data_size; i++) {
        int bin_index = (data[i] - data_min) / 10;
        if (bin_index >= 10) bin_index = 9;
        bins[bin_index]++;
    }
    
    for (int i = 0; i < 10; i++) {
        int range_start = data_min + i * 10;
        int range_end = range_start + 9;
        printf("%3d-%3d: ", range_start, range_end);
        
        for (int j = 0; j < bins[i]; j++) {
            printf("█");
        }
        printf(" (%d)\n", bins[i]);
    }
    printf("\n");
    
    // 3. 数据变换：傅里叶分析（简化版）
    printf("3. 数据变换 - 离散傅里叶变换(DFT)\n");
    
    const int DFT_SIZE = 8;
    double signal[DFT_SIZE] = {1, 2, 3, 4, 4, 3, 2, 1};
    double real[DFT_SIZE], imag[DFT_SIZE];
    
    printf("时域信号: ");
    for (int i = 0; i < DFT_SIZE; i++) {
        printf("%.1f ", signal[i]);
    }
    printf("\n");
    
    // DFT计算
    for (int k = 0; k < DFT_SIZE; k++) {
        real[k] = 0.0;
        imag[k] = 0.0;
        
        for (int n = 0; n < DFT_SIZE; n++) {
            double angle = 2 * M_PI * k * n / DFT_SIZE;
            real[k] += signal[n] * cos(angle);
            imag[k] -= signal[n] * sin(angle);
        }
    }
    
    printf("频域结果 (实部+虚部):\n");
    for (int k = 0; k < DFT_SIZE; k++) {
        printf("X[%d] = %6.2f + %6.2fi\n", k, real[k], imag[k]);
    }
    
    // 计算幅度谱
    printf("\n幅度谱:\n");
    for (int k = 0; k < DFT_SIZE; k++) {
        double magnitude = sqrt(real[k] * real[k] + imag[k] * imag[k]);
        printf("|X[%d]| = %.2f\n", k, magnitude);
    }
}

项目2：图像处理算法模拟

#include <stdio.h>
#include <math.h>

/**
 * 🖼️ 图像处理算法模拟
 * 功能：卷积操作、边缘检测、图像滤波、直方图均衡化
 */
void image_processing_simulation() {
    printf("🖼️ 图像处理算法模拟\n");
    printf("==================\n");
    
    // 模拟灰度图像数据 (8x8)
    int image[8][8] = {
        {50, 60, 70, 80, 90, 100, 110, 120},
        {55, 65, 75, 85, 95, 105, 115, 125},
        {60, 70, 80, 90, 100, 110, 120, 130},
        {65, 75, 85, 95, 105, 115, 125, 135},
        {70, 80, 90, 100, 110, 120, 130, 140},
        {75, 85, 95, 105, 115, 125, 135, 145},
        {80, 90, 100, 110, 120, 130, 140, 150},
        {85, 95, 105, 115, 125, 135, 145, 155}
    };
    
    // 1. 均值滤波
    printf("1. 均值滤波 (3x3卷积核)\n");
    
    int filtered[8][8] = {0};
    double kernel[3][3] = {
        {1.0/9, 1.0/9, 1.0/9},
        {1.0/9, 1.0/9, 1.0/9},
        {1.0/9, 1.0/9, 1.0/9}
    };
    
    printf("原始图像:\n");
    for (int i = 0; i < 8; i++) {
        for (int j = 0; j < 8; j++) {
            printf("%4d", image[i][j]);
        }
        printf("\n");
    }
    
    // 卷积操作（忽略边界）
    for (int i = 1; i < 7; i++) {
        for (int j = 1; j < 7; j++) {
            double sum = 0.0;
            
            for (int ki = -1; ki <= 1; ki++) {
                for (int kj = -1; kj <= 1; kj++) {
                    sum += image[i + ki][j + kj] * kernel[ki + 1][kj + 1];
                }
            }
            
            filtered[i][j] = (int)sum;
        }
    }
    
    printf("\n滤波后图像:\n");
    for (int i = 0; i < 8; i++) {
        for (int j = 0; j < 8; j++) {
            printf("%4d", filtered[i][j]);
        }
        printf("\n");
    }
    printf("\n");
    
    // 2. Sobel边缘检测
    printf("2. Sobel边缘检测\n");
    
    int sobel_x[3][3] = {{-1, 0, 1}, {-2, 0, 2}, {-1, 0, 1}};
    int sobel_y[3][3] = {{-1, -2, -1}, {0, 0, 0}, {1, 2, 1}};
    
    int gradient[8][8] = {0};
    
    for (int i = 1; i < 7; i++) {
        for (int j = 1; j < 7; j++) {
            int gx = 0, gy = 0;
            
            // 计算x方向和y方向的梯度
            for (int ki = -1; ki <= 1; ki++) {
                for (int kj = -1; kj <= 1; kj++) {
                    gx += image[i + ki][j + kj] * sobel_x[ki + 1][kj + 1];
                    gy += image[i + ki][j + kj] * sobel_y[ki + 1][kj + 1];
                }
            }
            
            // 梯度幅度
            gradient[i][j] = (int)sqrt(gx * gx + gy * gy);
            if (gradient[i][j] > 255) gradient[i][j] = 255; // 限制范围
        }
    }
    
    printf("边缘检测结果 (梯度幅度):\n");
    for (int i = 0; i < 8; i++) {
        for (int j = 0; j < 8; j++) {
            printf("%4d", gradient[i][j]);
        }
        printf("\n");
    }
    printf("\n");
    
    // 3. 直方图均衡化
    printf("3. 直方图均衡化\n");
    
    int histogram[256] = {0};
    int equalized[8][8] = {0};
    
    // 计算直方图
    for (int i = 0; i < 8; i++) {
        for (int j = 0; j < 8; j++) {
            histogram[image[i][j]]++;
        }
    }
    
    // 计算累积分布函数(CDF)
    int cdf[256] = {0};
    cdf[0] = histogram[0];
    for (int i = 1; i < 256; i++) {
        cdf[i] = cdf[i-1] + histogram[i];
    }
    
    // 寻找CDF最小值（忽略0值）
    int cdf_min = 64; // 图像总像素数
    for (int i = 0; i < 256; i++) {
        if (histogram[i] > 0 && cdf[i] < cdf_min) {
            cdf_min = cdf[i];
        }
    }
    
    // 直方图均衡化变换
    for (int i = 0; i < 8; i++) {
        for (int j = 0; j < 8; j++) {
            int pixel = image[i][j];
            int new_pixel = (int)((cdf[pixel] - cdf_min) * 255.0 / (64 - cdf_min));
            if (new_pixel < 0) new_pixel = 0;
            if (new_pixel > 255) new_pixel = 255;
            equalized[i][j] = new_pixel;
        }
    }
    
    printf("均衡化后图像:\n");
    for (int i = 0; i < 8; i++) {
        for (int j = 0; j < 8; j++) {
            printf("%4d", equalized[i][j]);
        }
        printf("\n");
    }
}

⚠️ 高级注意事项与最佳实践

4.3.5 for循环的工程原则

原则1：循环不变式与正确性证明

// 🔍 循环不变式示例：数组最大值查找
int find_max(const int arr[], int size) {
    // 前置条件: size > 0
    int max_val = arr[0];
    
    // 循环不变式: max_val == max(arr[0..i-1])
    for (int i = 1; i < size; i++) {
        // 保持循环不变式
        if (arr[i] > max_val) {
            max_val = arr[i];
        }
        // 不变式仍然成立: max_val == max(arr[0..i])
    }
    // 循环结束: i == size, 因此 max_val == max(arr[0..size-1])
    return max_val;
}

原则2：边界条件与安全性

// ✅ 安全的循环边界处理
void safe_array_processing() {
    int arr[100];
    int size = sizeof(arr) / sizeof(arr[0]);
    
    // 安全的边界检查
    for (int i = 0; i < size; i++) {
        arr[i] = i * i;
    }
    
    // 避免使用魔数作为边界
    const int MAX_SIZE = 100;
    int data[MAX_SIZE];
    
    for (int i = 0; i < MAX_SIZE; i++) {
        data[i] = 0;
    }
    
    // 处理动态大小数组
    int dynamic_size = 50;
    for (int i = 0; i < dynamic_size && i < MAX_SIZE; i++) {
        data[i] = i;
    }
}

4.3.6 性能优化与陷阱避免

优化1：循环强度削减

// 优化前
void unoptimized_computation() {
    int results[100];
    for (int i = 0; i < 100; i++) {
        results[i] = i * 2 + 5;  // 每次循环重复计算
    }
}

// 优化后 - 循环强度削减
void optimized_computation() {
    int results[100];
    int value = 5;  // 不变计算提到循环外
    
    for (int i = 0; i < 100; i++) {
        results[i] = value;
        value += 2;  // 用加法替代乘法
    }
}

优化2：数据局部性优化

// 缓存不友好的访问模式
void cache_unfriendly() {
    int matrix[1000][1000];
    
    // 列优先访问 - 缓存不友好
    for (int col = 0; col < 1000; col++) {
        for (int row = 0; row < 1000; row++) {
            matrix[row][col] = row + col;
        }
    }
}

// 缓存友好的访问模式
void cache_friendly() {
    int matrix[1000][1000];
    
    // 行优先访问 - 缓存友好
    for (int row = 0; row < 1000; row++) {
        for (int col = 0; col < 1000; col++) {
            matrix[row][col] = row + col;
        }
    }
}

陷阱1：浮点数循环控制

// ⚠️ 危险的浮点数循环
void dangerous_float_loop() {
    // 由于浮点数精度问题，这可能不会精确执行10次
    for (double x = 0.0; x != 1.0; x += 0.1) {
        printf("%f\n", x);
    }
}

// ✅ 安全的浮点数循环
void safe_float_loop() {
    // 使用整数控制循环
    for (int i = 0; i <= 10; i++) {
        double x = i * 0.1;
        printf("%f\n", x);
    }
    
    // 或者使用容差比较
    for (double x = 0.0; x <= 1.0 + 1e-9; x += 0.1) {
        printf("%f\n", x);
    }
}

陷阱2：循环变量修改

// ⚠️ 危险的循环变量修改
void dangerous_index_modification() {
    for (int i = 0; i < 10; i++) {
        if (i == 5) {
            i = 8;  // 跳过一些迭代 - 容易出错
        }
        printf("%d ", i);
    }
    // 输出: 0 1 2 3 4 8 9
}

// ✅ 明确的控制流
void clear_control_flow() {
    for (int i = 0; i < 10; i++) {
        if (i >= 5 && i <= 7) {
            continue;  // 明确跳过
        }
        printf("%d ", i);
    }
    // 输出: 0 1 2 3 4 8 9
}

📊 总结与知识图谱

4.3.7 for循环知识体系

概念层级 核心技术 应用场景 最佳实践
基础语法 三表达式控制、循环体 数值计算、数组遍历 清晰的循环控制
模式设计 嵌套循环、复杂条件 算法实现、数据处理 适当的循环分解
高级特性 性能优化、算法模式 高性能计算、系统编程 性能与可读性平衡
工程实践 边界安全、正确性验证 生产系统、关键应用 防御性编程

4.3.8 关键要点总结

1. 语义特性：for循环是确定性迭代，提供明确的循环控制
2. 适用场景：已知迭代次数、数组遍历、数值计算等确定性场景
3. 设计原则：确保循环边界安全、性能优化、逻辑清晰
4. 工程实践：结合算法思维、性能分析、代码质量

通过本节的深入学习，读者应能掌握for循环从基础语法到高级工程实践的全方位知识，特别在需要精确控制和性能优化的场景中能够做出恰当的技术选型和实现。for循环作为C语言中最常用且最高效的循环结构，是编写高质量C程序的基础。