C语言编程：50个实用实例深度解析，掌握核心技巧

实例1：变量声明与赋值

在C语言中，变量是存储数据的基本单位。以下是一个简单的变量声明与赋值实例：

#include <stdio.h>

int main() {
    int a = 10;  // 声明并初始化整型变量a
    float b = 3.14;  // 声明并初始化浮点型变量b
    char c = 'A';  // 声明并初始化字符型变量c
    return 0;
}

实例2：基本输入输出

输入输出是C语言中最基础的操作。以下是一个简单的输入输出实例：

#include <stdio.h>

int main() {
    int num;
    printf("请输入一个整数：");
    scanf("%d", &num);  // 从标准输入读取一个整数
    printf("你输入的整数是：%d\n", num);  // 将整数输出到标准输出
    return 0;
}

实例3：数据类型转换

在C语言中，数据类型转换是常见操作。以下是一个数据类型转换实例：

#include <stdio.h>

int main() {
    int a = 10;
    float b = 3.14;
    printf("a + b = %.2f\n", a + b);  // 将整型变量a转换为浮点型，然后与浮点型变量b相加
    return 0;
}

实例4：运算符优先级

了解运算符优先级对于编写正确的代码至关重要。以下是一个运算符优先级实例：

#include <stdio.h>

int main() {
    int a = 10, b = 5, c = 3;
    printf("(a + b) * c = %d\n", (a + b) * c);  // 先计算括号内的加法，再计算乘法
    printf("a + (b * c) = %d\n", a + (b * c));  // 先计算乘法，再计算加法
    return 0;
}

实例5：条件语句

条件语句用于根据条件执行不同的代码块。以下是一个条件语句实例：

#include <stdio.h>

int main() {
    int num = 10;
    if (num > 0) {
        printf("num是一个正数\n");
    } else {
        printf("num不是一个正数\n");
    }
    return 0;
}

实例6：循环语句

循环语句用于重复执行一段代码。以下是一个循环语句实例：

#include <stdio.h>

int main() {
    int i;
    for (i = 1; i <= 10; i++) {
        printf("%d\n", i);  // 打印1到10的数字
    }
    return 0;
}

实例7：数组操作

数组是存储一系列相同类型数据的基本单位。以下是一个数组操作实例：

#include <stdio.h>

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

实例8：函数定义与调用

函数是代码模块化的基础。以下是一个函数定义与调用实例：

#include <stdio.h>

void printMessage() {
    printf("Hello, world!\n");
}

int main() {
    printMessage();  // 调用函数printMessage
    return 0;
}

实例9：指针操作

指针是C语言中非常强大的特性。以下是一个指针操作实例：

#include <stdio.h>

int main() {
    int a = 10;
    int *ptr = &a;  // 指针ptr指向变量a的地址
    printf("a = %d\n", a);  // 打印变量a的值
    printf("*ptr = %d\n", *ptr);  // 通过指针ptr访问变量a的值
    return 0;
}

实例10：结构体

结构体用于存储不同类型的数据。以下是一个结构体实例：

#include <stdio.h>

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

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

实例11：位运算

位运算用于操作数据在内存中的位。以下是一个位运算实例：

#include <stdio.h>

int main() {
    int a = 5;  // 二进制：0000 0101
    int b = 3;  // 二进制：0000 0011
    printf("a & b = %d\n", a & b);  // 按位与操作
    printf("a | b = %d\n", a | b);  // 按位或操作
    printf("a ^ b = %d\n", a ^ b);  // 按位异或操作
    printf("a << 1 = %d\n", a << 1);  // 左移操作
    printf("a >> 1 = %d\n", a >> 1);  // 右移操作
    return 0;
}

实例12：文件操作

文件操作是C语言中常见的操作之一。以下是一个文件操作实例：

#include <stdio.h>

int main() {
    FILE *fp;
    fp = fopen("example.txt", "w");  // 以写入模式打开文件
    fprintf(fp, "Hello, world!\n");  // 将字符串写入文件
    fclose(fp);  // 关闭文件
    return 0;
}

实例13：动态内存分配

动态内存分配是C语言中重要的特性。以下是一个动态内存分配实例：

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

int main() {
    int *ptr = (int *)malloc(10 * sizeof(int));  // 分配10个整型数据的内存空间
    if (ptr == NULL) {
        printf("内存分配失败\n");
        return 0;
    }
    for (int i = 0; i < 10; i++) {
        ptr[i] = i + 1;  // 初始化数组
    }
    for (int i = 0; i < 10; i++) {
        printf("%d ", ptr[i]);  // 打印数组元素
    }
    printf("\n");
    free(ptr);  // 释放内存空间
    return 0;
}

实例14：字符串操作

字符串操作是C语言中常用的操作之一。以下是一个字符串操作实例：

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

int main() {
    char str1[50] = "Hello";
    char str2[50] = "world";
    strcat(str1, str2);  // 连接字符串str1和str2
    printf("%s\n", str1);  // 打印连接后的字符串
    strcpy(str1, "Hello, world!");  // 复制字符串
    printf("%s\n", str1);  // 打印复制后的字符串
    return 0;
}

实例15：结构体数组

结构体数组可以存储多个结构体数据。以下是一个结构体数组实例：

#include <stdio.h>

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

int main() {
    struct Person persons[2] = {
        {"张三", 20},
        {"李四", 25}
    };
    for (int i = 0; i < 2; i++) {
        printf("姓名：%s，年龄：%d\n", persons[i].name, persons[i].age);
    }
    return 0;
}

实例16：结构体指针

结构体指针可以用来操作结构体数据。以下是一个结构体指针实例：

#include <stdio.h>

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

int main() {
    struct Person p1 = {"张三", 20};
    struct Person *ptr = &p1;
    printf("姓名：%s，年龄：%d\n", (*ptr).name, (*ptr).age);  // 通过结构体指针访问结构体成员
    printf("姓名：%s，年龄：%d\n", ptr->name, ptr->age);  // 使用箭头操作符访问结构体成员
    return 0;
}

实例17：函数指针

函数指针可以指向函数。以下是一个函数指针实例：

#include <stdio.h>

void printMessage() {
    printf("Hello, world!\n");
}

int main() {
    void (*funcPtr)() = printMessage;  // 函数指针指向printMessage函数
    funcPtr();  // 调用函数指针
    return 0;
}

实例18：递归函数

递归函数是一种常用的算法设计方法。以下是一个递归函数实例：

#include <stdio.h>

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

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

实例19：指针数组

指针数组可以存储多个指针。以下是一个指针数组实例：

#include <stdio.h>

int main() {
    int a = 10;
    int b = 20;
    int *ptrs[2];
    ptrs[0] = &a;
    ptrs[1] = &b;
    for (int i = 0; i < 2; i++) {
        printf("*ptrs[%d] = %d\n", i, *ptrs[i]);  // 通过指针数组访问变量值
    }
    return 0;
}

实例20：动态分配二维数组

动态分配二维数组可以更灵活地处理数据。以下是一个动态分配二维数组实例：

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

int main() {
    int rows = 3;
    int cols = 4;
    int **arr = (int **)malloc(rows * sizeof(int *));
    for (int i = 0; i < rows; i++) {
        arr[i] = (int *)malloc(cols * sizeof(int));
        for (int j = 0; j < cols; j++) {
            arr[i][j] = i * cols + j;  // 初始化数组元素
        }
    }
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < cols; j++) {
            printf("%d ", arr[i][j]);  // 打印数组元素
        }
        printf("\n");
    }
    for (int i = 0; i < rows; i++) {
        free(arr[i]);  // 释放二维数组内存
    }
    free(arr);  // 释放指针数组内存
    return 0;
}

实例21：字符串比较

字符串比较是C语言中常用的操作之一。以下是一个字符串比较实例：

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

int main() {
    char str1[50] = "Hello";
    char str2[50] = "World";
    printf("strcmp(str1, str2) = %d\n", strcmp(str1, str2));  // 比较字符串str1和str2
    return 0;
}

实例22：字符串查找

字符串查找是C语言中常用的操作之一。以下是一个字符串查找实例：

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

int main() {
    char str1[50] = "Hello, world!";
    char substr[10] = "world";
    printf("strstr(str1, substr) = %d\n", strstr(str1, substr));  // 查找子字符串substr在str1中的位置
    return 0;
}

实例23：字符串替换

字符串替换是C语言中常用的操作之一。以下是一个字符串替换实例：

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

void replace(char *str, const char *oldstr, const char *newstr) {
    char buffer[1024];
    char *p;
    while ((p = strstr(str, oldstr)) != NULL) {
        strncpy(buffer, str, p - str);  // 复制旧字符串到缓冲区
        buffer[p - str - strlen(oldstr)] = '\0';  // 在旧字符串位置添加字符串结束符
        strcat(buffer, newstr);  // 添加新字符串
        strcat(buffer, str + p + strlen(oldstr));  // 添加剩余的字符串
        strcpy(str, buffer);  // 将新字符串复制回原字符串
    }
}

int main() {
    char str[50] = "Hello, world!";
    replace(str, "world", "C");
    printf("替换后的字符串：%s\n", str);
    return 0;
}

实例24：字符串分割

字符串分割是C语言中常用的操作之一。以下是一个字符串分割实例：

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

void split(const char *str, const char *delim, char **tokens) {
    char *p;
    int count = 0;
    while ((p = strtok((char *)str, delim)) != NULL) {
        tokens[count++] = p;
        str = p;  // 更新str指向下一个分割点
    }
}

int main() {
    char str[50] = "Hello, world!";
    char *tokens[10];
    split(str, " ", tokens);
    for (int i = 0; i < 2; i++) {
        printf("%s\n", tokens[i]);  // 打印分割后的字符串
    }
    return 0;
}

实例25：字符串排序

字符串排序是C语言中常用的操作之一。以下是一个字符串排序实例：

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

void sortStrings(char **strings, int n) {
    char temp[50];
    for (int i = 0; i < n - 1; i++) {
        for (int j = i + 1; j < n; j++) {
            if (strcmp(strings[i], strings[j]) > 0) {
                strcpy(temp, strings[i]);
                strcpy(strings[i], strings[j]);
                strcpy(strings[j], temp);
            }
        }
    }
}

int main() {
    char *strings[] = {"Hello", "World", "C", "Programming"};
    int n = sizeof(strings) / sizeof(strings[0]);
    sortStrings(strings, n);
    for (int i = 0; i < n; i++) {
        printf("%s\n", strings[i]);  // 打印排序后的字符串数组
    }
    return 0;
}

实例26：链表操作

链表是C语言中常用的数据结构之一。以下是一个链表操作实例：

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

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

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

void insertNode(Node **head, int data) {
    Node *node = createNode(data);
    if (*head == NULL) {
        *head = node;
    } else {
        Node *current = *head;
        while (current->next != NULL) {
            current = current->next;
        }
        current->next = node;
    }
}

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() {
    Node *head = NULL;
    insertNode(&head, 1);
    insertNode(&head, 2);
    insertNode(&head, 3);
    printList(head);
    freeList(head);
    return 0;
}

实例27：栈操作

栈是一种后进先出（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;
}

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

void push(Stack *s, int item) {
    if (isFull(s)) {
        printf("栈已满\n");
        return;
    }
    s->items[++s->top] = item;
}

int pop(Stack *s) {
    if (isEmpty(s)) {
        printf("栈为空\n");
        return -1;
    }
    return s->items[s->top--];
}

int main() {
    Stack s;
    initializeStack(&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;
}

实例28：队列操作

队列是一种先进先出（FIFO）的数据结构。以下是一个队列操作实例：

”`c #include #include

#define MAX_SIZE 100

typedef struct Queue {

int items[MAX_SIZE];
int front;
int rear;

} Queue;

void initializeQueue(Queue *q) {

q->front