每日一个C语言知识：C 数组

C语言数组详解

1. 什么是数组？

数组是一种用于存储固定大小的相同类型元素的顺序集合。数组中的所有元素在内存中是连续存储的，可以通过索引（下标）来访问每个元素。

数组的主要特点：

• 相同数据类型的元素集合
• 连续的内存空间
• 固定大小（声明时确定）
• 通过索引访问元素（从0开始）

---

2. 数组的基本概念

C语言数组 一维数组 多维数组 字符数组 数组与指针 单个索引 线性存储 二维数组 三维数组 字符串 字符处理 数组名即指针 指针运算

---

3. 一维数组

数组声明和初始化

#include <stdio.h>

int main() {
    printf("=== 一维数组基础 ===\n");
    
    // 方式1：声明后逐个初始化
    int numbers1[5];
    numbers1[0] = 10;
    numbers1[1] = 20;
    numbers1[2] = 30;
    numbers1[3] = 40;
    numbers1[4] = 50;
    
    // 方式2：声明时初始化
    int numbers2[5] = {1, 2, 3, 4, 5};
    
    // 方式3：自动计算数组大小
    int numbers3[] = {11, 22, 33, 44, 55};  // 编译器自动计算为5
    
    // 方式4：部分初始化（其余元素自动为0）
    int numbers4[5] = {1, 2};  // [1, 2, 0, 0, 0]
    
    // 显示数组内容
    printf("numbers1: ");
    for (int i = 0; i < 5; i++) {
        printf("%d ", numbers1[i]);
    }
    printf("\n");
    
    printf("numbers2: ");
    for (int i = 0; i < 5; i++) {
        printf("%d ", numbers2[i]);
    }
    printf("\n");
    
    printf("numbers3: ");
    for (int i = 0; i < 5; i++) {
        printf("%d ", numbers3[i]);
    }
    printf("\n");
    
    printf("numbers4: ");
    for (int i = 0; i < 5; i++) {
        printf("%d ", numbers4[i]);
    }
    printf("\n");
    
    return 0;
}

数组的常见操作

#include <stdio.h>

// 函数声明
void printArray(int arr[], int size);
int findMax(int arr[], int size);
int findMin(int arr[], int size);
int calculateSum(int arr[], int size);
float calculateAverage(int arr[], int size);
void reverseArray(int arr[], int size);

int main() {
    int numbers[] = {23, 45, 12, 67, 34, 89, 56};
    int size = sizeof(numbers) / sizeof(numbers[0]);
    
    printf("=== 数组常见操作 ===\n");
    
    printf("原始数组: ");
    printArray(numbers, size);
    
    printf("数组大小: %d\n", size);
    printf("最大值: %d\n", findMax(numbers, size));
    printf("最小值: %d\n", findMin(numbers, size));
    printf("总和: %d\n", calculateSum(numbers, size));
    printf("平均值: %.2f\n", calculateAverage(numbers, size));
    
    reverseArray(numbers, size);
    printf("反转后数组: ");
    printArray(numbers, size);
    
    return 0;
}

// 打印数组
void printArray(int arr[], int size) {
    for (int i = 0; i < size; i++) {
        printf("%d ", arr[i]);
    }
    printf("\n");
}

// 查找最大值
int findMax(int arr[], int size) {
    int max = arr[0];
    for (int i = 1; i < size; i++) {
        if (arr[i] > max) {
            max = arr[i];
        }
    }
    return max;
}

// 查找最小值
int findMin(int arr[], int size) {
    int min = arr[0];
    for (int i = 1; i < size; i++) {
        if (arr[i] < min) {
            min = arr[i];
        }
    }
    return min;
}

// 计算总和
int calculateSum(int arr[], int size) {
    int sum = 0;
    for (int i = 0; i < size; i++) {
        sum += arr[i];
    }
    return sum;
}

// 计算平均值
float calculateAverage(int arr[], int size) {
    int sum = calculateSum(arr, size);
    return (float)sum / size;
}

// 反转数组
void reverseArray(int arr[], int size) {
    for (int i = 0; i < size / 2; i++) {
        int temp = arr[i];
        arr[i] = arr[size - 1 - i];
        arr[size - 1 - i] = temp;
    }
}

数组排序算法

#include <stdio.h>

// 函数声明
void bubbleSort(int arr[], int size);
void selectionSort(int arr[], int size);
void printArray(int arr[], int size);

int main() {
    int numbers1[] = {64, 34, 25, 12, 22, 11, 90};
    int numbers2[] = {64, 34, 25, 12, 22, 11, 90};
    int size = sizeof(numbers1) / sizeof(numbers1[0]);
    
    printf("=== 数组排序算法 ===\n");
    
    printf("原始数组: ");
    printArray(numbers1, size);
    
    // 冒泡排序
    bubbleSort(numbers1, size);
    printf("冒泡排序后: ");
    printArray(numbers1, size);
    
    // 选择排序
    selectionSort(numbers2, size);
    printf("选择排序后: ");
    printArray(numbers2, size);
    
    return 0;
}

// 冒泡排序
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;
            }
        }
    }
}

// 选择排序
void selectionSort(int arr[], int size) {
    for (int i = 0; i < size - 1; i++) {
        int minIndex = i;
        for (int j = i + 1; j < size; j++) {
            if (arr[j] < arr[minIndex]) {
                minIndex = j;
            }
        }
        // 交换元素
        int temp = arr[i];
        arr[i] = arr[minIndex];
        arr[minIndex] = temp;
    }
}

void printArray(int arr[], int size) {
    for (int i = 0; i < size; i++) {
        printf("%d ", arr[i]);
    }
    printf("\n");
}

---

4. 多维数组

二维数组

#include <stdio.h>

#define ROWS 3
#define COLS 4

// 函数声明
void print2DArray(int arr[ROWS][COLS]);
int findMax2D(int arr[ROWS][COLS]);
int calculateSum2D(int arr[ROWS][COLS]);
void transposeMatrix(int arr[ROWS][COLS], int result[COLS][ROWS]);

int main() {
    // 二维数组的声明和初始化
    int matrix1[ROWS][COLS] = {
        {1, 2, 3, 4},
        {5, 6, 7, 8},
        {9, 10, 11, 12}
    };
    
    // 另一种初始化方式
    int matrix2[ROWS][COLS] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12};
    
    // 部分初始化
    int matrix3[ROWS][COLS] = {
        {1, 2},        // 第一行：1, 2, 0, 0
        {5, 6, 7},     // 第二行：5, 6, 7, 0
        {9}            // 第三行：9, 0, 0, 0
    };
    
    printf("=== 二维数组示例 ===\n");
    
    printf("matrix1:\n");
    print2DArray(matrix1);
    
    printf("matrix2:\n");
    print2DArray(matrix2);
    
    printf("matrix3:\n");
    print2DArray(matrix3);
    
    printf("二维数组最大值: %d\n", findMax2D(matrix1));
    printf("二维数组总和: %d\n", calculateSum2D(matrix1));
    
    // 矩阵转置
    int transposed[COLS][ROWS];
    transposeMatrix(matrix1, transposed);
    
    printf("转置矩阵:\n");
    for (int i = 0; i < COLS; i++) {
        for (int j = 0; j < ROWS; j++) {
            printf("%d ", transposed[i][j]);
        }
        printf("\n");
    }
    
    return 0;
}

// 打印二维数组
void print2DArray(int arr[ROWS][COLS]) {
    for (int i = 0; i < ROWS; i++) {
        for (int j = 0; j < COLS; j++) {
            printf("%d\t", arr[i][j]);
        }
        printf("\n");
    }
}

// 查找二维数组最大值
int findMax2D(int arr[ROWS][COLS]) {
    int max = arr[0][0];
    for (int i = 0; i < ROWS; i++) {
        for (int j = 0; j < COLS; j++) {
            if (arr[i][j] > max) {
                max = arr[i][j];
            }
        }
    }
    return max;
}

// 计算二维数组总和
int calculateSum2D(int arr[ROWS][COLS]) {
    int sum = 0;
    for (int i = 0; i < ROWS; i++) {
        for (int j = 0; j < COLS; j++) {
            sum += arr[i][j];
        }
    }
    return sum;
}

// 矩阵转置
void transposeMatrix(int arr[ROWS][COLS], int result[COLS][ROWS]) {
    for (int i = 0; i < ROWS; i++) {
        for (int j = 0; j < COLS; j++) {
            result[j][i] = arr[i][j];
        }
    }
}

二维数组的实际应用：学生成绩系统

#include <stdio.h>

#define STUDENTS 5
#define SUBJECTS 3

// 科目名称
const char* subjectNames[] = {"数学", "英语", "编程"};

// 函数声明
void inputGrades(int grades[STUDENTS][SUBJECTS]);
void printGradeTable(int grades[STUDENTS][SUBJECTS]);
void calculateStudentAverages(int grades[STUDENTS][SUBJECTS], float averages[]);
void calculateSubjectAverages(int grades[STUDENTS][SUBJECTS], float averages[]);
void findTopStudent(int grades[STUDENTS][SUBJECTS]);

int main() {
    int grades[STUDENTS][SUBJECTS];
    float studentAverages[STUDENTS];
    float subjectAverages[SUBJECTS];
    
    printf("=== 学生成绩管理系统 ===\n");
    
    // 输入成绩
    inputGrades(grades);
    
    // 显示成绩表
    printf("\n=== 成绩表 ===\n");
    printGradeTable(grades);
    
    // 计算学生平均分
    calculateStudentAverages(grades, studentAverages);
    printf("\n=== 学生平均分 ===\n");
    for (int i = 0; i < STUDENTS; i++) {
        printf("学生%d: %.2f\n", i + 1, studentAverages[i]);
    }
    
    // 计算科目平均分
    calculateSubjectAverages(grades, subjectAverages);
    printf("\n=== 科目平均分 ===\n");
    for (int i = 0; i < SUBJECTS; i++) {
        printf("%s: %.2f\n", subjectNames[i], subjectAverages[i]);
    }
    
    // 查找优秀学生
    findTopStudent(grades);
    
    return 0;
}

// 输入成绩
void inputGrades(int grades[STUDENTS][SUBJECTS]) {
    printf("请输入%d个学生的%d门科目成绩:\n", STUDENTS, SUBJECTS);
    for (int i = 0; i < STUDENTS; i++) {
        printf("学生%d:\n", i + 1);
        for (int j = 0; j < SUBJECTS; j++) {
            printf("  %s成绩: ", subjectNames[j]);
            scanf("%d", &grades[i][j]);
        }
    }
}

// 打印成绩表
void printGradeTable(int grades[STUDENTS][SUBJECTS]) {
    // 打印表头
    printf("学生\\科目\t");
    for (int j = 0; j < SUBJECTS; j++) {
        printf("%s\t", subjectNames[j]);
    }
    printf("\n");
    
    // 打印分隔线
    printf("--------\t");
    for (int j = 0; j < SUBJECTS; j++) {
        printf("----\t");
    }
    printf("\n");
    
    // 打印成绩
    for (int i = 0; i < STUDENTS; i++) {
        printf("学生%d\t\t", i + 1);
        for (int j = 0; j < SUBJECTS; j++) {
            printf("%d\t", grades[i][j]);
        }
        printf("\n");
    }
}

// 计算学生平均分
void calculateStudentAverages(int grades[STUDENTS][SUBJECTS], float averages[]) {
    for (int i = 0; i < STUDENTS; i++) {
        int sum = 0;
        for (int j = 0; j < SUBJECTS; j++) {
            sum += grades[i][j];
        }
        averages[i] = (float)sum / SUBJECTS;
    }
}

// 计算科目平均分
void calculateSubjectAverages(int grades[STUDENTS][SUBJECTS], float averages[]) {
    for (int j = 0; j < SUBJECTS; j++) {
        int sum = 0;
        for (int i = 0; i < STUDENTS; i++) {
            sum += grades[i][j];
        }
        averages[j] = (float)sum / STUDENTS;
    }
}

// 查找优秀学生
void findTopStudent(int grades[STUDENTS][SUBJECTS]) {
    int topStudent = 0;
    int maxTotal = 0;
    
    for (int i = 0; i < STUDENTS; i++) {
        int total = 0;
        for (int j = 0; j < SUBJECTS; j++) {
            total += grades[i][j];
        }
        
        if (total > maxTotal) {
            maxTotal = total;
            topStudent = i;
        }
    }
    
    printf("\n=== 优秀学生 ===\n");
    printf("学生%d (总分: %d)\n", topStudent + 1, maxTotal);
    printf("各科成绩: ");
    for (int j = 0; j < SUBJECTS; j++) {
        printf("%s:%d ", subjectNames[j], grades[topStudent][j]);
    }
    printf("\n");
}

三维数组

#include <stdio.h>

#define X 2
#define Y 3
#define Z 4

int main() {
    // 三维数组声明和初始化
    int cube[X][Y][Z] = {
        {   // 第一个二维平面
            {1, 2, 3, 4},
            {5, 6, 7, 8},
            {9, 10, 11, 12}
        },
        {   // 第二个二维平面
            {13, 14, 15, 16},
            {17, 18, 19, 20},
            {21, 22, 23, 24}
        }
    };
    
    printf("=== 三维数组示例 ===\n");
    
    // 访问三维数组元素
    printf("cube[0][1][2] = %d\n", cube[0][1][2]);  // 7
    printf("cube[1][2][3] = %d\n", cube[1][2][3]);  // 24
    
    // 遍历三维数组
    printf("\n三维数组内容:\n");
    for (int i = 0; i < X; i++) {
        printf("平面 %d:\n", i);
        for (int j = 0; j < Y; j++) {
            for (int k = 0; k < Z; k++) {
                printf("%d\t", cube[i][j][k]);
            }
            printf("\n");
        }
        printf("\n");
    }
    
    // 计算三维数组元素总和
    int total = 0;
    for (int i = 0; i < X; i++) {
        for (int j = 0; j < Y; j++) {
            for (int k = 0; k < Z; k++) {
                total += cube[i][j][k];
            }
        }
    }
    printf("三维数组元素总和: %d\n", total);
    
    return 0;
}

---

5. 字符数组和字符串

字符数组基础

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

int main() {
    printf("=== 字符数组和字符串 ===\n");
    
    // 方式1：字符数组（不是字符串，因为没有null终止符）
    char arr1[] = {'H', 'e', 'l', 'l', 'o'};
    
    // 方式2：字符串（以null字符'\0'结尾）
    char arr2[] = "Hello";
    
    // 方式3：指定大小的字符数组
    char arr3[10] = "Hello";
    
    // 方式4：逐个初始化
    char arr4[6];
    arr4[0] = 'H';
    arr4[1] = 'e';
    arr4[2] = 'l';
    arr4[3] = 'l';
    arr4[4] = 'o';
    arr4[5] = '\0';  // 重要：添加null终止符
    
    printf("arr1 (字符数组): ");
    for (int i = 0; i < 5; i++) {
        printf("%c", arr1[i]);
    }
    printf("\n");
    
    printf("arr2 (字符串): %s\n", arr2);
    printf("arr3: %s\n", arr3);
    printf("arr4: %s\n", arr4);
    
    // 字符串长度
    printf("arr2长度: %lu\n", strlen(arr2));
    printf("arr2数组大小: %lu\n", sizeof(arr2));  // 包括'\0'
    
    return 0;
}

字符串操作函数

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

int main() {
    char str1[50] = "Hello";
    char str2[50] = "World";
    char str3[100];
    char str4[50];
    
    printf("=== 字符串操作函数 ===\n");
    
    // 字符串长度
    printf("str1长度: %lu\n", strlen(str1));
    
    // 字符串复制
    strcpy(str3, str1);
    printf("复制后str3: %s\n", str3);
    
    // 字符串连接
    strcat(str3, " ");
    strcat(str3, str2);
    printf("连接后str3: %s\n", str3);
    
    // 字符串比较
    printf("str1和str2比较: %d\n", strcmp(str1, str2));
    printf("str1和\"Hello\"比较: %d\n", strcmp(str1, "Hello"));
    
    // 字符串查找
    char *found = strchr(str3, 'W');
    if (found != NULL) {
        printf("在str3中找到'W': %s\n", found);
    }
    
    // 子字符串查找
    found = strstr(str3, "World");
    if (found != NULL) {
        printf("在str3中找到\"World\": %s\n", found);
    }
    
    // 字符串分割
    char text[] = "apple,banana,cherry,date";
    char *token = strtok(text, ",");
    
    printf("分割字符串:\n");
    while (token != NULL) {
        printf("- %s\n", token);
        token = strtok(NULL, ",");
    }
    
    return 0;
}

自定义字符串函数

#include <stdio.h>

// 自定义字符串函数
int myStrlen(const char *str);
void myStrcpy(char *dest, const char *src);
void myStrcat(char *dest, const char *src);
int myStrcmp(const char *str1, const char *str2);

int main() {
    char str1[50] = "Hello";
    char str2[50] = "World";
    char result[100];
    
    printf("=== 自定义字符串函数 ===\n");
    
    printf("myStrlen(\"%s\") = %d\n", str1, myStrlen(str1));
    
    myStrcpy(result, str1);
    printf("myStrcpy: %s\n", result);
    
    myStrcat(result, " ");
    myStrcat(result, str2);
    printf("myStrcat: %s\n", result);
    
    printf("myStrcmp(\"%s\", \"%s\") = %d\n", str1, str2, myStrcmp(str1, str2));
    printf("myStrcmp(\"%s\", \"%s\") = %d\n", str1, "Hello", myStrcmp(str1, "Hello"));
    
    return 0;
}

// 自定义字符串长度函数
int myStrlen(const char *str) {
    int length = 0;
    while (str[length] != '\0') {
        length++;
    }
    return length;
}

// 自定义字符串复制函数
void myStrcpy(char *dest, const char *src) {
    int i = 0;
    while (src[i] != '\0') {
        dest[i] = src[i];
        i++;
    }
    dest[i] = '\0';  // 添加null终止符
}

// 自定义字符串连接函数
void myStrcat(char *dest, const char *src) {
    // 找到dest的结尾
    int dest_len = myStrlen(dest);
    int i = 0;
    
    // 将src复制到dest的结尾
    while (src[i] != '\0') {
        dest[dest_len + i] = src[i];
        i++;
    }
    dest[dest_len + i] = '\0';  // 添加null终止符
}

// 自定义字符串比较函数
int myStrcmp(const char *str1, const char *str2) {
    int i = 0;
    while (str1[i] != '\0' && str2[i] != '\0') {
        if (str1[i] != str2[i]) {
            return str1[i] - str2[i];
        }
        i++;
    }
    return str1[i] - str2[i];
}

---

6. 数组与指针的关系

数组名即指针

#include <stdio.h>

int main() {
    int numbers[] = {10, 20, 30, 40, 50};
    int size = sizeof(numbers) / sizeof(numbers[0]);
    
    printf("=== 数组与指针的关系 ===\n");
    
    printf("数组名numbers: %p\n", numbers);
    printf("&numbers[0]: %p\n", &numbers[0]);
    printf("数组名等于第一个元素的地址: %s\n", 
           numbers == &numbers[0] ? "是" : "否");
    
    // 通过指针访问数组元素
    printf("\n通过指针访问数组:\n");
    int *ptr = numbers;  // ptr指向数组的第一个元素
    
    for (int i = 0; i < size; i++) {
        printf("numbers[%d] = %d, *(ptr + %d) = %d\n", 
               i, numbers[i], i, *(ptr + i));
    }
    
    // 指针运算
    printf("\n指针运算:\n");
    printf("*ptr = %d\n", *ptr);        // 第一个元素
    printf("*(ptr + 1) = %d\n", *(ptr + 1));  // 第二个元素
    printf("*(ptr + 2) = %d\n", *(ptr + 2));  // 第三个元素
    
    // 修改数组元素通过指针
    *(ptr + 1) = 99;
    printf("\n修改后numbers[1] = %d\n", numbers[1]);
    
    return 0;
}

数组作为函数参数

#include <stdio.h>

// 函数声明
void processArray(int *arr, int size);
void modifyArray(int arr[], int size);

int main() {
    int numbers[] = {1, 2, 3, 4, 5};
    int size = sizeof(numbers) / sizeof(numbers[0]);
    
    printf("=== 数组作为函数参数 ===\n");
    
    printf("原始数组: ");
    for (int i = 0; i < size; i++) {
        printf("%d ", numbers[i]);
    }
    printf("\n");
    
    // 数组作为指针传递
    processArray(numbers, size);
    
    printf("processArray调用后: ");
    for (int i = 0; i < size; i++) {
        printf("%d ", numbers[i]);
    }
    printf("\n");
    
    // 数组作为数组传递
    modifyArray(numbers, size);
    
    printf("modifyArray调用后: ");
    for (int i = 0; i < size; i++) {
        printf("%d ", numbers[i]);
    }
    printf("\n");
    
    return 0;
}

// 使用指针语法
void processArray(int *arr, int size) {
    for (int i = 0; i < size; i++) {
        arr[i] *= 2;  // 修改数组元素
    }
}

// 使用数组语法（实际上还是指针）
void modifyArray(int arr[], int size) {
    for (int i = 0; i < size; i++) {
        arr[i] += 10;  // 修改数组元素
    }
}

---

7. 动态数组（使用指针和malloc）

#include <stdio.h>
#include <stdlib.h>

// 函数声明
int* createDynamicArray(int size);
void inputDynamicArray(int *arr, int size);
void printDynamicArray(int *arr, int size);
void freeDynamicArray(int *arr);

int main() {
    int size;
    int *dynamicArray;
    
    printf("=== 动态数组示例 ===\n");
    
    printf("请输入数组大小: ");
    scanf("%d", &size);
    
    if (size <= 0) {
        printf("错误：数组大小必须为正数！\n");
        return 1;
    }
    
    // 创建动态数组
    dynamicArray = createDynamicArray(size);
    if (dynamicArray == NULL) {
        printf("错误：内存分配失败！\n");
        return 1;
    }
    
    // 输入数组元素
    printf("请输入%d个整数:\n", size);
    inputDynamicArray(dynamicArray, size);
    
    // 显示数组元素
    printf("动态数组内容: ");
    printDynamicArray(dynamicArray, size);
    
    // 计算总和和平均值
    int sum = 0;
    for (int i = 0; i < size; i++) {
        sum += dynamicArray[i];
    }
    printf("总和: %d\n", sum);
    printf("平均值: %.2f\n", (float)sum / size);
    
    // 释放内存
    freeDynamicArray(dynamicArray);
    
    return 0;
}

// 创建动态数组
int* createDynamicArray(int size) {
    int *arr = (int*)malloc(size * sizeof(int));
    return arr;
}

// 输入动态数组
void inputDynamicArray(int *arr, int size) {
    for (int i = 0; i < size; i++) {
        printf("元素 %d: ", i + 1);
        scanf("%d", &arr[i]);
    }
}

// 打印动态数组
void printDynamicArray(int *arr, int size) {
    for (int i = 0; i < size; i++) {
        printf("%d ", arr[i]);
    }
    printf("\n");
}

// 释放动态数组内存
void freeDynamicArray(int *arr) {
    free(arr);
    printf("动态数组内存已释放\n");
}

---

8. 实际应用示例

示例1：投票统计系统

#include <stdio.h>

#define CANDIDATES 5
#define MAX_VOTERS 100

// 候选人名称
const char* candidateNames[] = {
    "张三", "李四", "王五", "赵六", "钱七"
};

int main() {
    int votes[CANDIDATES] = {0};  // 初始化所有候选人的票数为0
    int voterCount = 0;
    int choice;
    
    printf("=== 投票统计系统 ===\n");
    
    printf("候选人列表:\n");
    for (int i = 0; i < CANDIDATES; i++) {
        printf("%d. %s\n", i + 1, candidateNames[i]);
    }
    printf("0. 结束投票\n");
    
    // 收集投票
    while (voterCount < MAX_VOTERS) {
        printf("\n选民 %d, 请选择候选人 (1-%d, 0结束): ", 
               voterCount + 1, CANDIDATES);
        scanf("%d", &choice);
        
        if (choice == 0) {
            break;  // 结束投票
        }
        
        if (choice < 1 || choice > CANDIDATES) {
            printf("无效选择！请选择1-%d之间的数字。\n", CANDIDATES);
            continue;
        }
        
        // 记录投票
        votes[choice - 1]++;
        voterCount++;
        printf("感谢您的投票！\n");
    }
    
    // 显示投票结果
    printf("\n=== 投票结果 ===\n");
    printf("总投票数: %d\n", voterCount);
    
    int maxVotes = 0;
    int winner = -1;
    
    for (int i = 0; i < CANDIDATES; i++) {
        printf("%s: %d票 (%.1f%%)\n", 
               candidateNames[i], votes[i], 
               (float)votes[i] / voterCount * 100);
        
        if (votes[i] > maxVotes) {
            maxVotes = votes[i];
            winner = i;
        }
    }
    
    // 检查是否有并列第一
    int tieCount = 0;
    for (int i = 0; i < CANDIDATES; i++) {
        if (votes[i] == maxVotes) {
            tieCount++;
        }
    }
    
    if (tieCount > 1) {
        printf("\n并列第一的候选人:\n");
        for (int i = 0; i < CANDIDATES; i++) {
            if (votes[i] == maxVotes) {
                printf("- %s\n", candidateNames[i]);
            }
        }
    } else {
        printf("\n获胜者: %s (%d票)\n", candidateNames[winner], maxVotes);
    }
    
    return 0;
}

示例2：矩阵运算

#include <stdio.h>

#define ROWS 2
#define COLS 3

// 函数声明
void printMatrix(int matrix[ROWS][COLS], const char* name);
void addMatrices(int A[ROWS][COLS], int B[ROWS][COLS], int result[ROWS][COLS]);
void multiplyByScalar(int matrix[ROWS][COLS], int scalar, int result[ROWS][COLS]);
int findMatrixMax(int matrix[ROWS][COLS]);
int findMatrixMin(int matrix[ROWS][COLS]);

int main() {
    int matrixA[ROWS][COLS] = {
        {1, 2, 3},
        {4, 5, 6}
    };
    
    int matrixB[ROWS][COLS] = {
        {6, 5, 4},
        {3, 2, 1}
    };
    
    int result[ROWS][COLS];
    
    printf("=== 矩阵运算 ===\n");
    
    // 显示原始矩阵
    printMatrix(matrixA, "矩阵A");
    printMatrix(matrixB, "矩阵B");
    
    // 矩阵加法
    addMatrices(matrixA, matrixB, result);
    printMatrix(result, "A + B");
    
    // 标量乘法
    multiplyByScalar(matrixA, 2, result);
    printMatrix(result, "2 × A");
    
    // 查找最大值和最小值
    printf("矩阵A的最大值: %d\n", findMatrixMax(matrixA));
    printf("矩阵A的最小值: %d\n", findMatrixMin(matrixA));
    printf("矩阵B的最大值: %d\n", findMatrixMax(matrixB));
    printf("矩阵B的最小值: %d\n", findMatrixMin(matrixB));
    
    return 0;
}

// 打印矩阵
void printMatrix(int matrix[ROWS][COLS], const char* name) {
    printf("%s:\n", name);
    for (int i = 0; i < ROWS; i++) {
        for (int j = 0; j < COLS; j++) {
            printf("%d\t", matrix[i][j]);
        }
        printf("\n");
    }
    printf("\n");
}

// 矩阵加法
void addMatrices(int A[ROWS][COLS], int B[ROWS][COLS], int result[ROWS][COLS]) {
    for (int i = 0; i < ROWS; i++) {
        for (int j = 0; j < COLS; j++) {
            result[i][j] = A[i][j] + B[i][j];
        }
    }
}

// 标量乘法
void multiplyByScalar(int matrix[ROWS][COLS], int scalar, int result[ROWS][COLS]) {
    for (int i = 0; i < ROWS; i++) {
        for (int j = 0; j < COLS; j++) {
            result[i][j] = matrix[i][j] * scalar;
        }
    }
}

// 查找矩阵最大值
int findMatrixMax(int matrix[ROWS][COLS]) {
    int max = matrix[0][0];
    for (int i = 0; i < ROWS; i++) {
        for (int j = 0; j < COLS; j++) {
            if (matrix[i][j] > max) {
                max = matrix[i][j];
            }
        }
    }
    return max;
}

// 查找矩阵最小值
int findMatrixMin(int matrix[ROWS][COLS]) {
    int min = matrix[0][0];
    for (int i = 0; i < ROWS; i++) {
        for (int j = 0; j < COLS; j++) {
            if (matrix[i][j] < min) {
                min = matrix[i][j];
            }
        }
    }
    return min;
}

---

9. 数组的常见错误

#include <stdio.h>

int main() {
    printf("=== 数组常见错误 ===\n");
    
    int numbers[5] = {1, 2, 3, 4, 5};
    
    // ❌ 错误1：数组越界访问
    /*
    printf("numbers[5] = %d\n", numbers[5]);  // 越界访问
    printf("numbers[-1] = %d\n", numbers[-1]); // 越界访问
    */
    
    // ✅ 正确：使用有效索引
    printf("有效访问: numbers[0] = %d, numbers[4] = %d\n", 
           numbers[0], numbers[4]);
    
    // ❌ 错误2：数组整体赋值
    /*
    int arr1[3] = {1, 2, 3};
    int arr2[3];
    arr2 = arr1;  // 错误：不能直接赋值数组
    */
    
    // ✅ 正确：逐个元素复制
    int arr1[3] = {1, 2, 3};
    int arr2[3];
    for (int i = 0; i < 3; i++) {
        arr2[i] = arr1[i];
    }
    printf("数组复制成功\n");
    
    // ❌ 错误3：数组大小使用变量（C89标准）
    /*
    int size = 5;
    int arr[size];  // 在C89中错误，C99支持变长数组
    */
    
    // ✅ 正确：使用常量或宏定义大小
    #define SIZE 5
    int arr[SIZE];
    printf("使用常量定义数组大小\n");
    
    // ❌ 错误4：字符串未正确终止
    /*
    char str[5] = {'H', 'e', 'l', 'l', 'o'};  // 不是字符串，缺少'\0'
    printf("%s\n", str);  // 可能导致未定义行为
    */
    
    // ✅ 正确：确保字符串以'\0'结尾
    char str[6] = {'H', 'e', 'l', 'l', 'o', '\0'};
    printf("正确字符串: %s\n", str);
    
    return 0;
}

---