学会C语言，看这50个经典编程实例解析！从入门到精通，一招搞定编程难题

1. 打印“Hello, World!”

在C语言编程中，第一个程序通常是打印“Hello, World!”。这个例子简单易懂，是学习C语言的起点。

#include <stdio.h>

int main() {
    printf("Hello, World!\n");
    return 0;
}

2. 变量和数据类型

理解变量和数据类型是C语言的基础。以下代码展示了如何声明和使用整数、浮点数和字符变量。

#include <stdio.h>

int main() {
    int age = 16;
    float height = 1.75;
    char grade = 'A';
    printf("Age: %d\n", age);
    printf("Height: %.2f\n", height);
    printf("Grade: %c\n", grade);
    return 0;
}

3. 控制结构：if语句

if语句用于条件判断，以下代码演示了如何使用if语句来决定是否打印一条消息。

#include <stdio.h>

int main() {
    int isRaining = 1;
    if (isRaining) {
        printf("Take an umbrella!\n");
    }
    return 0;
}

4. 循环结构：for循环

for循环用于重复执行一段代码，以下代码展示了如何使用for循环打印1到10的数字。

#include <stdio.h>

int main() {
    for (int i = 1; i <= 10; i++) {
        printf("%d\n", i);
    }
    return 0;
}

5. 循环结构：while循环

while循环也用于重复执行代码，以下代码展示了如何使用while循环打印1到10的数字。

#include <stdio.h>

int main() {
    int i = 1;
    while (i <= 10) {
        printf("%d\n", i);
        i++;
    }
    return 0;
}

6. 数组

数组是存储一系列相同类型数据的一种方式。以下代码展示了如何声明和使用一个整数数组。

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

7. 函数

函数是C语言中的代码块，可以重复使用。以下代码展示了如何定义和使用一个简单的函数。

#include <stdio.h>

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

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

8. 指针

指针是存储变量地址的变量。以下代码展示了如何使用指针来访问和修改变量的值。

#include <stdio.h>

int main() {
    int x = 10;
    int *ptr = &x;
    printf("Value of x: %d\n", x);
    printf("Address of x: %p\n", (void *)ptr);
    printf("Value of *ptr: %d\n", *ptr);
    *ptr = 20;
    printf("New value of x: %d\n", x);
    return 0;
}

9. 结构体

结构体允许你将不同类型的数据组合成一个单一的复合数据类型。以下代码展示了如何定义和使用一个结构体。

#include <stdio.h>

typedef struct {
    char name[50];
    int age;
    float height;
} Person;

int main() {
    Person person = {"Alice", 25, 1.70};
    printf("Name: %s\n", person.name);
    printf("Age: %d\n", person.age);
    printf("Height: %.2f\n", person.height);
    return 0;
}

10. 链表

链表是一种常见的数据结构，用于存储一系列元素。以下代码展示了如何定义和使用一个简单的单向链表。

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

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

void insert(Node **head, int data) {
    Node *newNode = (Node *)malloc(sizeof(Node));
    newNode->data = 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;
    insert(&head, 1);
    insert(&head, 2);
    insert(&head, 3);
    printList(head);
    return 0;
}

11. 文件操作

C语言支持文件操作，以下代码展示了如何打开、读取和关闭一个文件。

#include <stdio.h>

int main() {
    FILE *file = fopen("example.txt", "r");
    if (file == NULL) {
        printf("Error opening file!\n");
        return 1;
    }
    char buffer[100];
    while (fgets(buffer, 100, file)) {
        printf("%s", buffer);
    }
    fclose(file);
    return 0;
}

12. 动态内存分配

动态内存分配允许你在程序运行时分配内存。以下代码展示了如何使用malloc和free函数。

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

int main() {
    int *array = (int *)malloc(5 * sizeof(int));
    if (array == NULL) {
        printf("Memory allocation failed!\n");
        return 1;
    }
    for (int i = 0; i < 5; i++) {
        array[i] = i;
    }
    for (int i = 0; i < 5; i++) {
        printf("%d ", array[i]);
    }
    free(array);
    return 0;
}

13. 预处理器指令

预处理器指令用于在编译前处理源代码。以下代码展示了如何使用预处理器指令。

#include <stdio.h>

#define MAX_SIZE 10

int main() {
    int array[MAX_SIZE];
    for (int i = 0; i < MAX_SIZE; i++) {
        array[i] = i;
    }
    for (int i = 0; i < MAX_SIZE; i++) {
        printf("%d ", array[i]);
    }
    printf("\n");
    return 0;
}

14. 错误处理

错误处理是编程中非常重要的一部分。以下代码展示了如何使用返回值和错误代码来处理错误。

#include <stdio.h>

int divide(int a, int b) {
    if (b == 0) {
        return -1; // 错误代码
    }
    return a / b;
}

int main() {
    int result = divide(10, 0);
    if (result == -1) {
        printf("Error: Division by zero!\n");
    } else {
        printf("Result: %d\n", result);
    }
    return 0;
}

15. 字符串处理

C语言提供了丰富的字符串处理函数。以下代码展示了如何使用字符串函数。

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

int main() {
    char str1[100] = "Hello";
    char str2[100] = "World";
    char result[200];
    strcpy(result, str1);
    strcat(result, str2);
    printf("Result: %s\n", result);
    printf("Length of str1: %lu\n", strlen(str1));
    return 0;
}

16. 时间和日期

C语言提供了时间处理库，以下代码展示了如何获取当前时间和日期。

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

int main() {
    time_t t = time(NULL);
    struct tm tm = *localtime(&t);
    printf("Current time: %d-%d-%d %d:%d:%d\n", tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday, tm.tm_hour, tm.tm_min, tm.tm_sec);
    return 0;
}

17. 网络编程

C语言支持网络编程，以下代码展示了如何使用socket发送和接收数据。

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <unistd.h>

int main() {
    int sockfd = socket(AF_INET, SOCK_STREAM, 0);
    struct sockaddr_in servaddr;
    memset(&servaddr, 0, sizeof(servaddr));
    servaddr.sin_family = AF_INET;
    servaddr.sin_port = htons(8080);
    servaddr.sin_addr.s_addr = INADDR_ANY;
    bind(sockfd, (struct sockaddr *)&servaddr, sizeof(servaddr));
    listen(sockfd, 10);
    int connfd = accept(sockfd, (struct sockaddr *)&servaddr, sizeof(servaddr));
    char buffer[1024];
    read(connfd, buffer, sizeof(buffer));
    printf("Received: %s\n", buffer);
    close(connfd);
    close(sockfd);
    return 0;
}

18. 图形编程

C语言可以用于图形编程，以下代码展示了如何使用OpenGL绘制一个三角形。

#include <GL/glut.h>

void display() {
    glClear(GL_COLOR_BUFFER_BIT);
    glBegin(GL_TRIANGLES);
    glVertex2f(0.0, 0.5);
    glVertex2f(-0.5, -0.5);
    glVertex2f(0.5, -0.5);
    glEnd();
    glFlush();
}

int main(int argc, char **argv) {
    glutInit(&argc, argv);
    glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB);
    glutInitWindowSize(400, 400);
    glutCreateWindow("OpenGL Triangle");
    glClearColor(1.0, 1.0, 1.0, 1.0);
    glutDisplayFunc(display);
    glutMainLoop();
    return 0;
}

19. 数据结构：栈

栈是一种后进先出（LIFO）的数据结构。以下代码展示了如何实现一个栈。

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

typedef struct Stack {
    int *array;
    int top;
    int capacity;
} Stack;

void initStack(Stack *s, int capacity) {
    s->array = (int *)malloc(capacity * sizeof(int));
    s->top = -1;
    s->capacity = capacity;
}

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

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

void push(Stack *s, int item) {
    if (isFull(s)) {
        printf("Stack is full!\n");
        return;
    }
    s->array[++s->top] = item;
}

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

int main() {
    Stack s;
    initStack(&s, 5);
    push(&s, 1);
    push(&s, 2);
    push(&s, 3);
    printf("Popped: %d\n", pop(&s));
    printf("Popped: %d\n", pop(&s));
    printf("Popped: %d\n", pop(&s));
    return 0;
}

20. 数据结构：队列

队列是一种先进先出（FIFO）的数据结构。以下代码展示了如何实现一个队列。

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

typedef struct Queue {
    int *array;
    int front;
    int rear;
    int size;
    int capacity;
} Queue;

void initQueue(Queue *q, int capacity) {
    q->array = (int *)malloc(capacity * sizeof(int));
    q->front = 0;
    q->rear = -1;
    q->size = 0;
    q->capacity = capacity;
}

int isFull(Queue *q) {
    return q->size == q->capacity;
}

int isEmpty(Queue *q) {
    return q->size == 0;
}

void enqueue(Queue *q, int item) {
    if (isFull(q)) {
        printf("Queue is full!\n");
        return;
    }
    q->rear = (q->rear + 1) % q->capacity;
    q->array[q->rear] = item;
    q->size++;
}

int dequeue(Queue *q) {
    if (isEmpty(q)) {
        printf("Queue is empty!\n");
        return -1;
    }
    int item = q->array[q->front];
    q->front = (q->front + 1) % q->capacity;
    q->size--;
    return item;
}

int main() {
    Queue q;
    initQueue(&q, 5);
    enqueue(&q, 1);
    enqueue(&q, 2);
    enqueue(&q, 3);
    printf("Dequeued: %d\n", dequeue(&q));
    printf("Dequeued: %d\n", dequeue(&q));
    printf("Dequeued: %d\n", dequeue(&q));
    return 0;
}

21. 数据结构：链表

链表是一种常见的数据结构，用于存储一系列元素。以下代码展示了如何定义和使用一个单向链表。

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

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

void insert(Node **head, int data) {
    Node *newNode = (Node *)malloc(sizeof(Node));
    newNode->data = 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;
    insert(&head, 1);
    insert(&head, 2);
    insert(&head, 3);
    printList(head);
    return 0;
}

22. 数据结构：树

树是一种层次化的数据结构，用于存储具有父子关系的元素。以下代码展示了如何定义和使用一个二叉树。

#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 insert(Node *root, int data) {
    if (data < root->data) {
        if (root->left == NULL) {
            root->left = createNode(data);
        } else {
            insert(root->left, data);
        }
    } else {
        if (root->right == NULL) {
            root->right = createNode(data);
        } else {
            insert(root->right, data);
        }
    }
}

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

int main() {
    Node *root = createNode(5);
    insert(root, 3);
    insert(root, 7);
    insert(root, 2);
    insert(root, 4);
    insert(root, 6);
    insert(root, 8);
    printInOrder(root);
    return 0;
}

23. 数据结构：图

图是一种用于表示对象之间关系的图形结构。以下代码展示了如何定义和使用一个邻接表表示的图。

#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 numVertices) {
    Graph *graph = (Graph *)malloc(sizeof(Graph));
    graph->numVertices = numVertices;
    graph->adjLists = (Node **)malloc(numVertices * sizeof(Node *));
    graph->visited = (int *)malloc(numVertices * sizeof(int));
    for (int i = 0; i < numVertices; 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;
}

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() {
    int numVertices = 4;
    Graph *graph = createGraph(numVertices);
    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 Search:\n");
    DFS(graph, 2);

    return 0;
}

24. 数据结构：散列表

散列表（也称为哈希表）是一种基于散列函数的数据结构，用于存储键值对。以下代码展示了如何实现一个简单的散列表。

”`c #include #include

#define TABLE_SIZE 10

typedef struct Node {

int key;
int value;
struct Node *next;

} Node;

typedef struct HashTable {

Node **table;

} HashTable;

unsigned int hash(int key) {

return key % TABLE_SIZE;

}

HashTable *createHashTable() {

HashTable *hashTable = (HashTable *)malloc(sizeof(HashTable));
hashTable->table = (Node **)malloc(TABLE_SIZE * sizeof(Node *));
for (int i