掌握C语言编程，看这50个实战案例，轻松上手实战技巧

1. C语言基础入门

1.1 数据类型与变量

C语言中的数据类型包括整型、浮点型、字符型等。变量是存储数据的容器，通过声明变量来使用它们。

#include <stdio.h>

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

1.2 运算符与表达式

C语言中的运算符包括算术运算符、关系运算符、逻辑运算符等。表达式是由运算符和操作数组成的式子。

#include <stdio.h>

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

2. 控制结构

2.1 顺序结构

顺序结构是按照程序语句的先后顺序执行。

#include <stdio.h>

int main() {
    int a = 10;
    printf("a的值是：%d\n", a);
    a = a + 5;
    printf("a的值变为：%d\n", a);
    return 0;
}

2.2 选择结构

选择结构根据条件判断执行不同的语句。

#include <stdio.h>

int main() {
    int a = 10;
    if (a > 5) {
        printf("a大于5\n");
    } else {
        printf("a不大于5\n");
    }
    return 0;
}

2.3 循环结构

循环结构用于重复执行一段代码。

#include <stdio.h>

int main() {
    int i;
    for (i = 1; i <= 5; i++) {
        printf("i的值是：%d\n", i);
    }
    return 0;
}

3. 函数

3.1 函数定义与调用

函数是C语言中的基本模块，用于实现代码的复用。

#include <stdio.h>

void printMessage() {
    printf("这是一个函数\n");
}

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

3.2 参数传递与返回值

函数可以通过参数传递数据，并返回计算结果。

#include <stdio.h>

int add(int a, int b) {
    return a + b;
}

int main() {
    int result = add(3, 4);
    printf("结果是：%d\n", result);
    return 0;
}

4. 数组

4.1 一维数组

一维数组用于存储一组具有相同数据类型的元素。

#include <stdio.h>

int main() {
    int arr[5] = {1, 2, 3, 4, 5};
    for (int i = 0; i < 5; i++) {
        printf("arr[%d]的值是：%d\n", i, arr[i]);
    }
    return 0;
}

4.2 二维数组

二维数组用于存储具有多行多列的元素。

#include <stdio.h>

int main() {
    int arr[2][3] = {{1, 2, 3}, {4, 5, 6}};
    for (int i = 0; i < 2; i++) {
        for (int j = 0; j < 3; j++) {
            printf("arr[%d][%d]的值是：%d\n", i, j, arr[i][j]);
        }
    }
    return 0;
}

5. 指针

5.1 指针定义与使用

指针是存储变量地址的变量，用于实现数据的间接访问。

#include <stdio.h>

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

5.2 指针数组与函数指针

指针数组用于存储多个指针，函数指针用于指向函数。

#include <stdio.h>

void printMessage() {
    printf("这是一个函数\n");
}

int main() {
    void (*funcPtr)(void) = printMessage;
    funcPtr();
    return 0;
}

6. 结构体与联合体

6.1 结构体

结构体用于将不同数据类型的变量组合成一个整体。

#include <stdio.h>

struct Student {
    char name[50];
    int age;
    float score;
};

int main() {
    struct Student stu;
    strcpy(stu.name, "张三");
    stu.age = 20;
    stu.score = 90.5;
    printf("姓名：%s\n", stu.name);
    printf("年龄：%d\n", stu.age);
    printf("成绩：%f\n", stu.score);
    return 0;
}

6.2 联合体

联合体用于存储多个数据类型，但同一时间只能存储其中一个数据类型。

#include <stdio.h>

union Data {
    int i;
    float f;
    char c[4];
};

int main() {
    union Data u;
    u.i = 10;
    printf("整型值：%d\n", u.i);
    u.f = 3.14;
    printf("浮点型值：%f\n", u.f);
    printf("字符型值：%s\n", u.c);
    return 0;
}

7. 文件操作

7.1 文件打开与关闭

文件操作包括文件的打开、读取、写入和关闭。

#include <stdio.h>

int main() {
    FILE *fp = fopen("example.txt", "w");
    if (fp == NULL) {
        printf("文件打开失败\n");
        return 1;
    }
    fprintf(fp, "这是一个示例文件\n");
    fclose(fp);
    return 0;
}

7.2 文件读取与写入

文件读取与写入可以使用fscanf、fprintf、fgets、fputs等函数实现。

#include <stdio.h>

int main() {
    FILE *fp = fopen("example.txt", "r");
    if (fp == NULL) {
        printf("文件打开失败\n");
        return 1;
    }
    char buffer[100];
    while (fgets(buffer, sizeof(buffer), fp)) {
        printf("%s", buffer);
    }
    fclose(fp);
    return 0;
}

8. 动态内存分配

8.1 动态内存分配与释放

动态内存分配可以使用malloc、calloc、realloc等函数实现。

#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;
}

8.2 内存拷贝与释放

内存拷贝可以使用memcpy、memmove等函数实现。

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

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

9. 链表

9.1 单链表

单链表是一种常见的线性数据结构，由多个节点组成，每个节点包含数据和指向下一个节点的指针。

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

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

Node *createList(int arr[], int size) {
    Node *head = NULL, *tail = NULL;
    for (int i = 0; i < size; i++) {
        Node *newNode = (Node *)malloc(sizeof(Node));
        newNode->data = arr[i];
        newNode->next = NULL;
        if (head == NULL) {
            head = newNode;
            tail = newNode;
        } else {
            tail->next = newNode;
            tail = newNode;
        }
    }
    return head;
}

void printList(Node *head) {
    Node *current = head;
    while (current != NULL) {
        printf("%d ", current->data);
        current = current->next;
    }
    printf("\n");
}

void freeList(Node *head) {
    Node *current = head;
    while (current != NULL) {
        Node *temp = current;
        current = current->next;
        free(temp);
    }
}

int main() {
    int arr[] = {1, 2, 3, 4, 5};
    int size = sizeof(arr) / sizeof(arr[0]);
    Node *head = createList(arr, size);
    printList(head);
    freeList(head);
    return 0;
}

9.2 双链表

双链表是单链表的扩展，每个节点包含数据和指向前后节点的指针。

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

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

Node *createList(int arr[], int size) {
    Node *head = NULL, *tail = NULL;
    for (int i = 0; i < size; i++) {
        Node *newNode = (Node *)malloc(sizeof(Node));
        newNode->data = arr[i];
        newNode->prev = NULL;
        newNode->next = NULL;
        if (head == NULL) {
            head = newNode;
            tail = newNode;
        } else {
            tail->next = newNode;
            newNode->prev = tail;
            tail = newNode;
        }
    }
    return head;
}

void printList(Node *head) {
    Node *current = head;
    while (current != NULL) {
        printf("%d ", current->data);
        current = current->next;
    }
    printf("\n");
}

void freeList(Node *head) {
    Node *current = head;
    while (current != NULL) {
        Node *temp = current;
        current = current->next;
        free(temp);
    }
}

int main() {
    int arr[] = {1, 2, 3, 4, 5};
    int size = sizeof(arr) / sizeof(arr[0]);
    Node *head = createList(arr, size);
    printList(head);
    freeList(head);
    return 0;
}

10. 栈与队列

10.1 栈

栈是一种后进先出（LIFO）的数据结构，可以使用数组或链表实现。

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

#define MAX_SIZE 100

typedef struct Stack {
    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 value) {
    if (isFull(s)) {
        printf("栈已满\n");
        return;
    }
    s->data[++s->top] = value;
}

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", pop(&s));
    return 0;
}

10.2 队列

队列是一种先进先出（FIFO）的数据结构，可以使用数组或链表实现。

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

#define MAX_SIZE 100

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

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

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

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

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

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

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;
}

11. 树与图

11.1 树

树是一种非线性数据结构，由节点组成，每个节点包含数据和指向子节点的指针。

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

typedef struct TreeNode {
    int data;
    struct TreeNode *left;
    struct TreeNode *right;
} TreeNode;

TreeNode *createNode(int value) {
    TreeNode *node = (TreeNode *)malloc(sizeof(TreeNode));
    node->data = value;
    node->left = NULL;
    node->right = NULL;
    return node;
}

void insertNode(TreeNode *root, int value) {
    if (root == NULL) {
        root = createNode(value);
    } else if (value < root->data) {
        insertNode(root->left, value);
    } else {
        insertNode(root->right, value);
    }
}

void inorderTraversal(TreeNode *root) {
    if (root != NULL) {
        inorderTraversal(root->left);
        printf("%d ", root->data);
        inorderTraversal(root->right);
    }
}

void freeTree(TreeNode *root) {
    if (root != NULL) {
        freeTree(root->left);
        freeTree(root->right);
        free(root);
    }
}

int main() {
    TreeNode *root = NULL;
    insertNode(root, 5);
    insertNode(root, 3);
    insertNode(root, 7);
    insertNode(root, 2);
    insertNode(root, 4);
    insertNode(root, 6);
    insertNode(root, 8);
    printf("中序遍历结果：");
    inorderTraversal(root);
    printf("\n");
    freeTree(root);
    return 0;
}

11.2 图

图是一种非线性数据结构，由节点和边组成，节点表示实体，边表示实体之间的关系。

”`c #include #include

#define MAX_SIZE 100

typedef struct Graph {

int numVertices;
int **adjMatrix;

} Graph;

Graph *createGraph(int numVertices) {

Graph *graph = (Graph *)malloc(sizeof(Graph));
graph->numVertices = numVertices;
graph->adjMatrix = (int **)malloc(numVertices * sizeof(int *));
for (int i = 0; i < numVertices; i++) {
    graph->adjMatrix[i] = (int *)malloc(numVertices * sizeof(int));
    for (int j = 0; j < numVertices; j++) {
        graph->adjMatrix[i][j] = 0;
    }
}
return graph;

}

void addEdge(Graph *graph, int src, int dest) {

graph->adjMatrix[src][dest] = 1;
graph->adjMatrix[dest][src] = 1;

}

void freeGraph(Graph *graph) {

for (int i = 0; i < graph->numVertices; i++) {
    free(graph->adjMatrix[i]);
}
free(graph->adjMatrix);
free(graph);

}

int main() {

int numVertices = 4;
Graph *graph = createGraph(numVertices);
addEdge(graph, 0, 1);
addEdge(graph, 0, 2);
addEdge(graph, 1, 2);
addEdge(graph, 2, 3);
printf("邻接矩阵：\n");
for (int i = 0; i < numVertices; i++) {
    for