掌握C语言编程，从50个实战案例入手，轻松提升编程技能

C语言作为一种历史悠久且功能强大的编程语言，在系统编程、嵌入式开发等领域依然占据着重要地位。对于初学者来说，掌握C语言编程需要通过大量的实战练习。本文将从50个实战案例入手，帮助你轻松提升编程技能。

实战案例一：C语言基础语法

1. 变量和数据类型

#include <stdio.h>

int main() {
    int a = 10;
    float b = 3.14;
    char c = 'A';
    printf("整数：%d\n", a);
    printf("浮点数：%f\n", b);
    printf("字符：%c\n", c);
    return 0;
}

1. 运算符和表达式

#include <stdio.h>

int main() {
    int a = 5, b = 3;
    printf("加法：%d\n", a + b);
    printf("减法：%d\n", a - b);
    printf("乘法：%d\n", a * b);
    printf("除法：%d\n", a / b);
    return 0;
}

1. 控制语句

#include <stdio.h>

int main() {
    int a = 10;
    if (a > 5) {
        printf("a大于5\n");
    } else {
        printf("a不大于5\n");
    }
    for (int i = 0; i < 5; i++) {
        printf("循环：%d\n", i);
    }
    return 0;
}

实战案例二：函数和模块化编程

1. 函数定义和调用

#include <stdio.h>

void printHello() {
    printf("Hello, World!\n");
}

int main() {
    printHello();
    return 0;
}

1. 递归函数

#include <stdio.h>

int factorial(int n) {
    if (n <= 1) {
        return 1;
    } else {
        return n * factorial(n - 1);
    }
}

int main() {
    int num = 5;
    printf("5的阶乘：%d\n", factorial(num));
    return 0;
}

实战案例三：指针和内存管理

1. 指针定义和赋值

#include <stdio.h>

int main() {
    int a = 10;
    int *ptr = &a;
    printf("a的地址：%p\n", (void *)ptr);
    printf("a的值：%d\n", *ptr);
    return 0;
}

1. 动态内存分配

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

int main() {
    int *ptr = (int *)malloc(sizeof(int));
    if (ptr != NULL) {
        *ptr = 10;
        printf("动态分配的内存地址：%p\n", (void *)ptr);
        printf("动态分配的内存值：%d\n", *ptr);
        free(ptr);
    }
    return 0;
}

实战案例四：结构体和联合体

1. 结构体定义和初始化

#include <stdio.h>

typedef struct {
    int id;
    char name[20];
} Student;

int main() {
    Student stu = {1, "张三"};
    printf("学生ID：%d\n", stu.id);
    printf("学生姓名：%s\n", stu.name);
    return 0;
}

1. 联合体定义和初始化

#include <stdio.h>

typedef union {
    int id;
    char name[20];
} Student;

int main() {
    Student stu = {1};
    printf("学生ID：%d\n", stu.id);
    stu.id = 2;
    printf("学生姓名：%s\n", stu.name);
    return 0;
}

实战案例五：文件操作

1. 打开文件

#include <stdio.h>

int main() {
    FILE *fp = fopen("example.txt", "r");
    if (fp == NULL) {
        printf("文件打开失败\n");
        return 1;
    }
    return 0;
}

1. 读取文件

#include <stdio.h>

int main() {
    FILE *fp = fopen("example.txt", "r");
    if (fp == NULL) {
        printf("文件打开失败\n");
        return 1;
    }
    char ch;
    while ((ch = fgetc(fp)) != EOF) {
        printf("%c", ch);
    }
    fclose(fp);
    return 0;
}

实战案例六：字符串处理

1. 字符串定义和初始化

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

int main() {
    char str1[20] = "Hello";
    char str2[20] = "World";
    printf("str1：%s\n", str1);
    printf("str2：%s\n", str2);
    return 0;
}

1. 字符串连接

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

int main() {
    char str1[40] = "Hello, ";
    char str2[] = "World!";
    strcat(str1, str2);
    printf("str1：%s\n", str1);
    return 0;
}

实战案例七：动态数组

1. 动态数组定义和初始化

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

int main() {
    int *arr = (int *)malloc(5 * sizeof(int));
    if (arr == NULL) {
        printf("内存分配失败\n");
        return 1;
    }
    for (int i = 0; i < 5; i++) {
        arr[i] = i + 1;
    }
    for (int i = 0; i < 5; i++) {
        printf("arr[%d]：%d\n", i, arr[i]);
    }
    free(arr);
    return 0;
}

1. 动态数组扩容

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

int main() {
    int *arr = (int *)malloc(5 * sizeof(int));
    if (arr == NULL) {
        printf("内存分配失败\n");
        return 1;
    }
    for (int i = 0; i < 5; i++) {
        arr[i] = i + 1;
    }
    int *new_arr = (int *)realloc(arr, 10 * sizeof(int));
    if (new_arr == NULL) {
        printf("内存扩容失败\n");
        free(arr);
        return 1;
    }
    arr = new_arr;
    for (int i = 5; i < 10; i++) {
        arr[i] = i + 1;
    }
    for (int i = 0; i < 10; i++) {
        printf("arr[%d]：%d\n", i, arr[i]);
    }
    free(arr);
    return 0;
}

实战案例八：链表

1. 链表节点定义和创建

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

typedef struct Node {
    int data;
    struct Node *next;
} Node;

Node *createNode(int data) {
    Node *newNode = (Node *)malloc(sizeof(Node));
    if (newNode == NULL) {
        printf("内存分配失败\n");
        return NULL;
    }
    newNode->data = data;
    newNode->next = NULL;
    return newNode;
}

int main() {
    Node *head = createNode(1);
    Node *node1 = createNode(2);
    Node *node2 = createNode(3);
    head->next = node1;
    node1->next = node2;
    return 0;
}

1. 链表插入和删除操作

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

typedef struct Node {
    int data;
    struct Node *next;
} Node;

Node *createNode(int data) {
    Node *newNode = (Node *)malloc(sizeof(Node));
    if (newNode == NULL) {
        printf("内存分配失败\n");
        return NULL;
    }
    newNode->data = data;
    newNode->next = NULL;
    return newNode;
}

void insertNode(Node **head, int data) {
    Node *newNode = createNode(data);
    newNode->next = *head;
    *head = newNode;
}

void deleteNode(Node **head, int data) {
    Node *temp = *head, *prev = NULL;
    while (temp != NULL && temp->data != data) {
        prev = temp;
        temp = temp->next;
    }
    if (temp == NULL) {
        printf("未找到元素\n");
        return;
    }
    if (prev == NULL) {
        *head = temp->next;
    } else {
        prev->next = temp->next;
    }
    free(temp);
}

int main() {
    Node *head = NULL;
    insertNode(&head, 1);
    insertNode(&head, 2);
    insertNode(&head, 3);
    for (Node *temp = head; temp != NULL; temp = temp->next) {
        printf("%d ", temp->data);
    }
    printf("\n");
    deleteNode(&head, 2);
    for (Node *temp = head; temp != NULL; temp = temp->next) {
        printf("%d ", temp->data);
    }
    printf("\n");
    return 0;
}

实战案例九：排序算法

1. 冒泡排序

#include <stdio.h>

void bubbleSort(int *arr, int n) {
    for (int i = 0; i < n - 1; i++) {
        for (int j = 0; j < n - i - 1; j++) {
            if (arr[j] > arr[j + 1]) {
                int temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
    }
}

int main() {
    int arr[] = {5, 2, 8, 4, 1};
    int n = sizeof(arr) / sizeof(arr[0]);
    bubbleSort(arr, n);
    for (int i = 0; i < n; i++) {
        printf("%d ", arr[i]);
    }
    printf("\n");
    return 0;
}

1. 选择排序

#include <stdio.h>

void selectionSort(int *arr, int n) {
    for (int i = 0; i < n - 1; i++) {
        int min_idx = i;
        for (int j = i + 1; j < n; j++) {
            if (arr[j] < arr[min_idx]) {
                min_idx = j;
            }
        }
        int temp = arr[min_idx];
        arr[min_idx] = arr[i];
        arr[i] = temp;
    }
}

int main() {
    int arr[] = {5, 2, 8, 4, 1};
    int n = sizeof(arr) / sizeof(arr[0]);
    selectionSort(arr, n);
    for (int i = 0; i < n; i++) {
        printf("%d ", arr[i]);
    }
    printf("\n");
    return 0;
}

实战案例十：查找算法

1. 线性查找

#include <stdio.h>

int linearSearch(int *arr, int n, int x) {
    for (int i = 0; i < n; i++) {
        if (arr[i] == x) {
            return i;
        }
    }
    return -1;
}

int main() {
    int arr[] = {5, 2, 8, 4, 1};
    int n = sizeof(arr) / sizeof(arr[0]);
    int x = 4;
    int result = linearSearch(arr, n, x);
    if (result == -1) {
        printf("未找到元素\n");
    } else {
        printf("元素位置：%d\n", result);
    }
    return 0;
}

1. 二分查找

#include <stdio.h>

int binarySearch(int *arr, int n, int x) {
    int low = 0, high = n - 1;
    while (low <= high) {
        int mid = low + (high - low) / 2;
        if (arr[mid] == x) {
            return mid;
        } else if (arr[mid] < x) {
            low = mid + 1;
        } else {
            high = mid - 1;
        }
    }
    return -1;
}

int main() {
    int arr[] = {1, 2, 3, 4, 5};
    int n = sizeof(arr) / sizeof(arr[0]);
    int x = 3;
    int result = binarySearch(arr, n, x);
    if (result == -1) {
        printf("未找到元素\n");
    } else {
        printf("元素位置：%d\n", result);
    }
    return 0;
}

实战案例十一：队列

1. 队列定义和初始化

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

#define MAX_SIZE 10

typedef struct {
    int data[MAX_SIZE];
    int front;
    int rear;
} Queue;

void initQueue(Queue *q) {
    q->front = 0;
    q->rear = 0;
}

int isEmpty(Queue *q) {
    return q->front == q->rear;
}

int isFull(Queue *q) {
    return (q->rear + 1) % MAX_SIZE == q->front;
}

void enqueue(Queue *q, int x) {
    if (isFull(q)) {
        printf("队列已满\n");
        return;
    }
    q->data[q->rear] = x;
    q->rear = (q->rear + 1) % MAX_SIZE;
}

int dequeue(Queue *q) {
    if (isEmpty(q)) {
        printf("队列已空\n");
        return -1;
    }
    int x = q->data[q->front];
    q->front = (q->front + 1) % MAX_SIZE;
    return x;
}

int main() {
    Queue q;
    initQueue(&q);
    enqueue(&q, 1);
    enqueue(&q, 2);
    enqueue(&q, 3);
    printf("队列元素：%d\n", dequeue(&q));
    printf("队列元素：%d\n", dequeue(&q));
    printf("队列元素：%d\n", dequeue(&q));
    return 0;
}

1. 队列应用：广度优先搜索（BFS）

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

#define MAX_SIZE 10

typedef struct {
    int data[MAX_SIZE];
    int front;
    int rear;
} Queue;

void initQueue(Queue *q) {
    q->front = 0;
    q->rear = 0;
}

int isEmpty(Queue *q) {
    return q->front == q->rear;
}

int isFull(Queue *q) {
    return (q->rear + 1) % MAX_SIZE == q->front;
}

void enqueue(Queue *q, int x) {
    if (isFull(q)) {
        printf("队列已满\n");
        return;
    }
    q->data[q->rear] = x;
    q->rear = (q->rear + 1) % MAX_SIZE;
}

int dequeue(Queue *q) {
    if (isEmpty(q)) {
        printf("队列已空\n");
        return -1;
    }
    int x = q->data[q->front];
    q->front = (q->front + 1) % MAX_SIZE;
    return x;
}

void bfs(int **graph, int n, int start) {
    Queue q;
    initQueue(&q);
    int visited[n];
    for (int i = 0; i < n; i++) {
        visited[i] = 0;
    }
    visited[start] = 1;
    enqueue(&q, start);
    while (!isEmpty(&q)) {
        int node = dequeue(&q);
        printf("%d ", node);
        for (int i = 0; i < n; i++) {
            if (graph[node][i] == 1 && !visited[i]) {
                visited[i] = 1;
                enqueue(&q, i);
            }
        }
    }
}

int main() {
    int n = 5;
    int **graph = (int **)malloc(n * sizeof(int *));
    for (int i = 0; i < n; i++) {
        graph[i] = (int *)malloc(n * sizeof(int));
        for (int j = 0; j < n; j++) {
            graph[i][j] = 0;
        }
    }
    graph[0][1] = 1;
    graph[1][0] = 1;
    graph[0][2] = 1;
    graph[2][0] = 1;
    graph[1][2] = 1;
    graph[2][1] = 1;
    bfs(graph, n, 0);
    return 0;
}

实战案例十二：栈

1. 栈定义和初始化

”`c #include #include

#define MAX_SIZE 10

typedef struct {

int data[MAX_SIZE];
int top;

} Stack;

void initStack(Stack *s) {

s->top = -1;

}

int isEmpty(Stack *s) {

return s->top == -1;

}

int isFull(Stack *s) {

return s->top == MAX_SIZE - 1;

}

void push(Stack *s, int x) {

if (isFull(s)) {
    printf("栈已满\n");
    return;
}
s->data[++s->top] = x;

}

int pop(Stack *s) {

if (isEmpty(s)) {
    printf("栈已空\n");
    return -1;
}
return s->data[s->top--];

}

int main() {

Stack s;
initStack(&s);
push(&s, 1);
push(&s, 2);
push(&s, 3);
printf("栈元素：%d\n", pop(&s));
printf("栈元素：%d\n", pop(&s));
printf("栈元素：%d\n",