掌握C语言编程，从这50个实用实例开始学习

C语言作为一门历史悠久的编程语言，因其高效、简洁和可移植性而被广泛应用于系统开发、嵌入式系统以及各种底层编程中。为了帮助您更好地掌握C语言编程，以下列出50个实用实例，涵盖基础语法、数据结构、算法等多个方面。

实例1：变量和常量

#include <stdio.h>

int main() {
    int age = 25; // 变量
    const int pi = 3.14159; // 常量
    printf("年龄：%d，圆周率：%f\n", age, pi);
    return 0;
}

实例2：数据类型转换

#include <stdio.h>

int main() {
    int num = 10;
    float f = num; // 整型转换为浮点型
    printf("转换后的浮点数：%f\n", f);
    return 0;
}

实例3：运算符

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

实例4：条件语句

#include <stdio.h>

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

实例5：循环结构

#include <stdio.h>

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

实例6：指针

#include <stdio.h>

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

实例7：结构体

#include <stdio.h>

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

int main() {
    Person p;
    strcpy(p.name, "张三");
    p.age = 25;
    printf("姓名：%s，年龄：%d\n", p.name, p.age);
    return 0;
}

实例8：函数

#include <stdio.h>

int add(int x, int y) {
    return x + y;
}

int main() {
    int a = 10, b = 20;
    printf("两数之和：%d\n", add(a, b));
    return 0;
}

实例9：数组

#include <stdio.h>

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

实例10：字符串

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

int main() {
    char str1[50] = "Hello";
    char str2[50] = "World";
    strcat(str1, str2); // 连接字符串
    printf("连接后的字符串：%s\n", str1);
    return 0;
}

实例11：文件操作

#include <stdio.h>

int main() {
    FILE *fp = fopen("example.txt", "w");
    if (fp == NULL) {
        printf("文件打开失败\n");
        return -1;
    }
    fprintf(fp, "Hello, World!");
    fclose(fp);
    return 0;
}

实例12：动态内存分配

#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;
    }
    for (int i = 0; i < 5; i++) {
        printf("动态数组元素：%d\n", arr[i]);
    }
    free(arr);
    return 0;
}

实例13：链表

#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) {
    while (head != NULL) {
        printf("链表元素：%d\n", head->data);
        head = head->next;
    }
}

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

实例14：栈

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

#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 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));
    return 0;
}

实例15：队列

#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 = 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 value) {
    if (isFull(q)) {
        printf("队列已满\n");
        return;
    }
    q->data[q->rear] = value;
    q->rear = (q->rear + 1) % MAX_SIZE;
}

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

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));
    return 0;
}

实例16：排序算法

#include <stdio.h>

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

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

实例17：查找算法

#include <stdio.h>

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

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

int main() {
    int arr[] = {1, 2, 3, 4, 5};
    int size = sizeof(arr) / sizeof(arr[0]);
    int value = 3;
    printf("线性查找：%d\n", linearSearch(arr, size, value));
    printf("二分查找：%d\n", binarySearch(arr, size, value));
    return 0;
}

实例18：递归

#include <stdio.h>

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

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

实例19：指针与数组

#include <stdio.h>

void swap(int *x, int *y) {
    int temp = *x;
    *x = *y;
    *y = temp;
}

int main() {
    int arr[] = {1, 2, 3, 4, 5};
    int size = sizeof(arr) / sizeof(arr[0]);
    for (int i = 0; i < size / 2; i++) {
        swap(&arr[i], &arr[size - i - 1]);
    }
    for (int i = 0; i < size; i++) {
        printf("数组元素：%d\n", arr[i]);
    }
    return 0;
}

实例20：结构体数组

#include <stdio.h>

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

int main() {
    Person arr[] = {
        {"张三", 25},
        {"李四", 30},
        {"王五", 35}
    };
    int size = sizeof(arr) / sizeof(arr[0]);
    for (int i = 0; i < size; i++) {
        printf("姓名：%s，年龄：%d\n", arr[i].name, arr[i].age);
    }
    return 0;
}

实例21：结构体指针

#include <stdio.h>

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

void printPerson(Person *p) {
    printf("姓名：%s，年龄：%d\n", p->name, p->age);
}

int main() {
    Person p;
    strcpy(p.name, "张三");
    p.age = 25;
    printPerson(&p);
    return 0;
}

实例22：结构体数组排序

#include <stdio.h>

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

int compareAge(const void *a, const void *b) {
    return ((Person *)a)->age - ((Person *)b)->age;
}

int main() {
    Person arr[] = {
        {"张三", 25},
        {"李四", 30},
        {"王五", 35}
    };
    int size = sizeof(arr) / sizeof(arr[0]);
    qsort(arr, size, sizeof(Person), compareAge);
    for (int i = 0; i < size; i++) {
        printf("姓名：%s，年龄：%d\n", arr[i].name, arr[i].age);
    }
    return 0;
}

实例23：链表遍历

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

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

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

int main() {
    Node *head = NULL, *tail = NULL;
    for (int i = 1; i <= 5; i++) {
        Node *newNode = (Node *)malloc(sizeof(Node));
        newNode->data = i;
        newNode->next = NULL;
        if (head == NULL) {
            head = newNode;
            tail = newNode;
        } else {
            tail->next = newNode;
            tail = newNode;
        }
    }
    printList(head);
    return 0;
}

实例24：链表反转

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

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

Node *reverseList(Node *head) {
    Node *prev = NULL, *current = head, *next = NULL;
    while (current != NULL) {
        next = current->next;
        current->next = prev;
        prev = current;
        current = next;
    }
    return prev;
}

int main() {
    Node *head = NULL, *tail = NULL;
    for (int i = 1; i <= 5; i++) {
        Node *newNode = (Node *)malloc(sizeof(Node));
        newNode->data = i;
        newNode->next = NULL;
        if (head == NULL) {
            head = newNode;
            tail = newNode;
        } else {
            tail->next = newNode;
            tail = newNode;
        }
    }
    printf("反转前的链表：");
    printList(head);
    head = reverseList(head);
    printf("反转后的链表：");
    printList(head);
    return 0;
}

实例25：栈与队列

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

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

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

void initQueue(Queue *q) {
    q->front = 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 value) {
    if (isFull(q)) {
        printf("队列已满\n");
        return;
    }
    q->data[q->rear] = value;
    q->rear = (q->rear + 1) % MAX_SIZE;
}

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

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

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

实例26：递归与循环

#include <stdio.h>

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

int main() {
    int n = 5;
    printf("递归阶乘：%d\n", factorial(n));
    printf("循环阶乘：%d\n", factorialLoop(n));
    return 0;
}

int factorialLoop(int n) {
    int result = 1;
    for (int i = 1; i <= n; i++) {
        result *= i;
    }
    return result;
}

实例27：函数指针

”`c #include

int add(int x, int y) {

return x + y;

}

int subtract(int x, int y) {

return x - y;

}

int main() {