掌握C语言，看懂这50个实战案例，轻松提升编程技能

1. 基础语法与数据类型

1.1 变量和常量

在C语言中，变量是存储数据的地方，而常量则是不可改变的值。以下是一个简单的例子：

#include <stdio.h>

int main() {
    int age = 25; // 变量
    const float pi = 3.14159; // 常量

    printf("Age: %d\n", age);
    printf("Pi: %.5f\n", pi);

    return 0;
}

1.2 数据类型

C语言支持多种数据类型，包括整数、浮点数、字符等。以下是一个简单的数据类型示例：

#include <stdio.h>

int main() {
    int number = 10;
    float fnumber = 10.5;
    char letter = 'A';

    printf("Integer: %d\n", number);
    printf("Float: %.2f\n", fnumber);
    printf("Character: %c\n", letter);

    return 0;
}

2. 控制语句

2.1 条件语句

条件语句用于根据条件执行不同的代码块。以下是一个简单的if-else示例：

#include <stdio.h>

int main() {
    int age = 18;

    if (age >= 18) {
        printf("You are an adult.\n");
    } else {
        printf("You are not an adult.\n");
    }

    return 0;
}

2.2 循环语句

循环语句用于重复执行代码块。以下是一个简单的for循环示例：

#include <stdio.h>

int main() {
    for (int i = 1; i <= 5; i++) {
        printf("Count: %d\n", i);
    }

    return 0;
}

3. 函数

3.1 自定义函数

自定义函数是C语言的核心概念之一。以下是一个简单的自定义函数示例：

#include <stdio.h>

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

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

3.2 参数与返回值

函数可以接受参数并返回值。以下是一个计算两个数字之和的函数示例：

#include <stdio.h>

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

int main() {
    int result = sum(5, 10);
    printf("Sum: %d\n", result);
    return 0;
}

4. 数组与指针

4.1 数组

数组是一组相同类型的元素。以下是一个简单的整数数组示例：

#include <stdio.h>

int main() {
    int numbers[5] = {1, 2, 3, 4, 5};

    for (int i = 0; i < 5; i++) {
        printf("Number %d: %d\n", i, numbers[i]);
    }

    return 0;
}

4.2 指针

指针是存储变量地址的变量。以下是一个简单的指针示例：

#include <stdio.h>

int main() {
    int a = 10;
    int *ptr = &a;

    printf("Value of a: %d\n", a);
    printf("Address of a: %p\n", (void *)&a);
    printf("Value of ptr: %p\n", (void *)ptr);
    printf("Value of *ptr: %d\n", *ptr);

    return 0;
}

5. 文件操作

5.1 打开文件

在C语言中，可以使用fopen函数打开文件。以下是一个打开文件的示例：

#include <stdio.h>

int main() {
    FILE *file = fopen("example.txt", "r");
    if (file == NULL) {
        printf("Error opening file.\n");
        return 1;
    }

    char ch;
    while ((ch = fgetc(file)) != EOF) {
        printf("%c", ch);
    }

    fclose(file);
    return 0;
}

5.2 写入文件

可以使用fputs或fprintf函数将数据写入文件。以下是一个写入文件的示例：

#include <stdio.h>

int main() {
    FILE *file = fopen("example.txt", "w");
    if (file == NULL) {
        printf("Error opening file.\n");
        return 1;
    }

    fprintf(file, "Hello, World!\n");
    fclose(file);
    return 0;
}

6. 链表

6.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));
    newNode->data = data;
    newNode->next = NULL;
    return newNode;
}

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

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

int main() {
    Node *head = NULL;
    insertAtBeginning(&head, 3);
    insertAtBeginning(&head, 2);
    insertAtBeginning(&head, 1);

    printList(head);

    return 0;
}

7. 栈与队列

7.1 栈

栈是一种后进先出（LIFO）的数据结构。以下是一个简单的栈实现：

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

#define MAX_SIZE 100

typedef struct Stack {
    int items[MAX_SIZE];
    int top;
} Stack;

void initializeStack(Stack *s) {
    s->top = -1;
}

int isEmpty(Stack *s) {
    return s->top == -1;
}

void push(Stack *s, int item) {
    if (s->top < MAX_SIZE - 1) {
        s->items[++s->top] = item;
    } else {
        printf("Stack is full.\n");
    }
}

int pop(Stack *s) {
    if (!isEmpty(s)) {
        return s->items[s->top--];
    } else {
        printf("Stack is empty.\n");
        return -1;
    }
}

int main() {
    Stack s;
    initializeStack(&s);

    push(&s, 10);
    push(&s, 20);
    push(&s, 30);

    printf("Popped item: %d\n", pop(&s));
    printf("Popped item: %d\n", pop(&s));

    return 0;
}

7.2 队列

队列是一种先进先出（FIFO）的数据结构。以下是一个简单的队列实现：

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

#define MAX_SIZE 100

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

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

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

void enqueue(Queue *q, int item) {
    if ((q->rear + 1) % MAX_SIZE == q->front) {
        printf("Queue is full.\n");
    } else {
        if (isEmpty(q)) {
            q->front = q->rear = 0;
        } else {
            q->rear = (q->rear + 1) % MAX_SIZE;
        }
        q->items[q->rear] = item;
    }
}

int dequeue(Queue *q) {
    if (isEmpty(q)) {
        printf("Queue is empty.\n");
        return -1;
    } else {
        int item = q->items[q->front];
        if (q->front == q->rear) {
            q->front = q->rear = -1;
        } else {
            q->front = (q->front + 1) % MAX_SIZE;
        }
        return item;
    }
}

int main() {
    Queue q;
    initializeQueue(&q);

    enqueue(&q, 10);
    enqueue(&q, 20);
    enqueue(&q, 30);

    printf("Dequeued item: %d\n", dequeue(&q));
    printf("Dequeued item: %d\n", dequeue(&q));

    return 0;
}

8. 字符串处理

8.1 字符串比较

在C语言中，可以使用strcmp函数比较两个字符串。以下是一个字符串比较的示例：

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

int main() {
    char str1[] = "Hello";
    char str2[] = "World";

    if (strcmp(str1, str2) == 0) {
        printf("Strings are equal.\n");
    } else if (strcmp(str1, str2) < 0) {
        printf("str1 is less than str2.\n");
    } else {
        printf("str1 is greater than str2.\n");
    }

    return 0;
}

8.2 字符串连接

可以使用strcat函数将两个字符串连接起来。以下是一个字符串连接的示例：

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

int main() {
    char str1[] = "Hello, ";
    char str2[] = "World!";
    char result[50];

    strcpy(result, str1);
    strcat(result, str2);

    printf("Result: %s\n", result);

    return 0;
}

9. 网络编程

9.1 套接字

套接字是网络编程中用于建立连接的接口。以下是一个简单的TCP套接字客户端示例：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <arpa/inet.h>

int main() {
    int sock = 0;
    struct sockaddr_in serv_addr;

    if ((sock = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
        printf("\n Socket creation error \n");
        return -1;
    }

    memset(&serv_addr, '0', sizeof(serv_addr));

    serv_addr.sin_family = AF_INET;
    serv_addr.sin_port = htons(8080);

    if (inet_pton(AF_INET, "127.0.0.1", &serv_addr.sin_addr) <= 0) {
        printf("\nInvalid address/ Address not supported \n");
        return -1;
    }

    if (connect(sock, (struct sockaddr *)&serv_addr, sizeof(serv_addr)) < 0) {
        printf("\nConnection Failed \n");
        return -1;
    }

    char buffer[1024] = "Hello, Server!";
    send(sock, buffer, strlen(buffer), 0);

    char server_reply[1024];
    int valread = read(sock, server_reply, 1024);
    printf("%s\n", server_reply);

    close(sock);
    return 0;
}

9.2 UDP编程

UDP编程是另一种网络编程方法，它不保证数据包的顺序和可靠性。以下是一个简单的UDP客户端示例：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <arpa/inet.h>

int main() {
    int sock = 0;
    struct sockaddr_in serv_addr;

    if ((sock = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
        printf("\n Socket creation error \n");
        return -1;
    }

    memset(&serv_addr, '0', sizeof(serv_addr));

    serv_addr.sin_family = AF_INET;
    serv_addr.sin_port = htons(8080);

    if (inet_pton(AF_INET, "127.0.0.1", &serv_addr.sin_addr) <= 0) {
        printf("\nInvalid address/ Address not supported \n");
        return -1;
    }

    char buffer[1024] = "Hello, Server!";
    sendto(sock, (const char *)buffer, strlen(buffer), 0, (const struct sockaddr *)&serv_addr, sizeof(serv_addr));

    char server_reply[1024];
    int valread = recvfrom(sock, (char *)server_reply, 1024, 0, (struct sockaddr *)&serv_addr, (socklen_t*)&sizeof(serv_addr));
    printf("%s\n", server_reply);

    close(sock);
    return 0;
}

10. 图形编程

10.1 使用SDL库

SDL（Simple DirectMedia Layer）是一个用于开发游戏和图形应用程序的库。以下是一个简单的SDL程序示例：

#include <SDL.h>

int main() {
    SDL_Window *window = NULL;
    SDL_Renderer *renderer = NULL;

    if (SDL_Init(SDL_INIT_VIDEO) < 0) {
        printf("SDL could not initialize! SDL_Error: %s\n", SDL_GetError());
        return 1;
    }

    window = SDL_CreateWindow("SDL Tutorial", SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, 640, 480, SDL_WINDOW_SHOWN);
    if (window == NULL) {
        printf("Window could not be created! SDL_Error: %s\n", SDL_GetError());
        return 1;
    }

    renderer = SDL_CreateRenderer(window, -1, SDL_RENDERER_ACCELERATED);
    if (renderer == NULL) {
        printf("Renderer could not be created! SDL_Error: %s\n", SDL_GetError());
        return 1;
    }

    SDL_SetRenderDrawColor(renderer, 255, 255, 255, 255);
    SDL_RenderClear(renderer);

    SDL_SetRenderDrawColor(renderer, 0, 0, 0, 255);
    SDL_RenderFillRect(renderer, &SDL_Rect{100, 100, 200, 200});

    SDL_RenderPresent(renderer);

    SDL_Delay(5000);

    SDL_DestroyRenderer(renderer);
    SDL_DestroyWindow(window);
    SDL_Quit();

    return 0;
}

11. 数据结构

11.1 树

树是一种非线性数据结构，用于存储具有父子关系的元素。以下是一个简单的二叉树实现：

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

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

Node* createNode(int data) {
    Node *newNode = (Node *)malloc(sizeof(Node));
    newNode->data = data;
    newNode->left = NULL;
    newNode->right = NULL;
    return newNode;
}

void insertNode(Node **root, int data) {
    if (*root == NULL) {
        *root = createNode(data);
    } else {
        Node *current = *root;
        while (current != NULL) {
            if (data < current->data) {
                if (current->left == NULL) {
                    current->left = createNode(data);
                    break;
                }
                current = current->left;
            } else {
                if (current->right == NULL) {
                    current->right = createNode(data);
                    break;
                }
                current = current->right;
            }
        }
    }
}

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

int main() {
    Node *root = NULL;
    insertNode(&root, 5);
    insertNode(&root, 3);
    insertNode(&root, 7);
    insertNode(&root, 2);
    insertNode(&root, 4);
    insertNode(&root, 6);
    insertNode(&root, 8);

    printf("Inorder traversal: ");
    inorderTraversal(root);
    printf("\n");

    return 0;
}

11.2 图

图是一种用于表示对象之间关系的抽象数据结构。以下是一个简单的邻接表实现：

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

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

typedef struct Graph {
    int numVertices;
    Node **adjLists;
    int *visited;
} Graph;

Graph* createGraph(int vertices) {
    Graph *graph = (Graph *)malloc(sizeof(Graph));
    graph->numVertices = vertices;

    graph->adjLists = (Node **)malloc(vertices * sizeof(Node *));
    graph->visited = (int *)malloc(vertices * sizeof(int));

    for (int i = 0; i < vertices; i++) {
        graph->adjLists[i] = NULL;
        graph->visited[i] = 0;
    }

    return graph;
}

void addEdge(Graph *graph, int src, int dest) {
    Node *newNode = (Node *)malloc(sizeof(Node));
    newNode->data = dest;
    newNode->next = graph->adjLists[src];
    graph->adjLists[src] = newNode;

    newNode = (Node *)malloc(sizeof(Node));
    newNode->data = src;
    newNode->next = graph->adjLists[dest];
    graph->adjLists[dest] = newNode;
}

void DFS(Graph *graph, int vertex) {
    Node *adjList = graph->adjLists[vertex];
    Node *temp = adjList;

    graph->visited[vertex] = 1;
    printf("%d ", vertex);

    while (temp != NULL) {
        int connectedVertex = temp->data;

        if (graph->visited[connectedVertex] == 0) {
            DFS(graph, connectedVertex);
        }
        temp = temp->next;
    }
}

int main() {
    Graph *graph = createGraph(4);
    addEdge(graph, 0, 1);
    addEdge(graph, 0, 2);
    addEdge(graph, 1, 2);
    addEdge(graph, 2, 0);
    addEdge(graph, 2, 3);
    addEdge(graph, 3, 3);

    printf("Depth First Traversal: ");
    DFS(graph, 2);
    printf("\n");

    return 0;
}

12. 操作系统

12.1 进程管理

进程是操作系统中的基本运行单元。以下是一个简单的进程创建示例：

”`c #include #include #include #include

int main() {

pid_t pid = fork();