Logo

【揭秘C语言编程】26种核心技术，10个实战案例深度解析

作者：用户DGDG 更新时间：2025-05-29 09:04:39 阅读时间： 2分钟

1. 数据类型与变量

C语言中提供了丰富的数据类型，如整型（int）、浮点型（float）、字符型（char）等。理解这些数据类型及其范围对于编写正确的程序至关重要。

实战案例：数据类型转换

#include <stdio.h>

int main() {
    int num = 10;
    float fnum = 10.5f;
    printf("Integer: %d\n", num);
    printf("Float: %f\n", fnum);
    return 0;
}

2. 运算符

C语言提供了多种运算符，包括算术运算符、比较运算符、逻辑运算符等。

实战案例：算术运算符

#include <stdio.h>

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

3. 控制结构

控制结构包括条件语句（if-else）、循环语句（for、while、do-while）。

实战案例：if-else语句

#include <stdio.h>

int main() {
    int num = 10;
    if (num > 0) {
        printf("Number is positive\n");
    } else {
        printf("Number is negative or zero\n");
    }
    return 0;
}

4. 循环

循环语句用于重复执行代码块。

实战案例：for循环

#include <stdio.h>

int main() {
    for (int i = 0; i < 5; i++) {
        printf("Value of i: %d\n", i);
    }
    return 0;
}

5. 函数

函数是代码组织的基本单元，可以实现代码复用和模块化。

实战案例：自定义函数

#include <stdio.h>

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

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

6. 数组

数组用于存储同类型元素集合。

实战案例：二维数组

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

7. 指针

指针是C语言的核心特性之一，它允许程序员直接操作内存地址。

实战案例：指针与数组

#include <stdio.h>

int main() {
    int arr[3] = {1, 2, 3};
    int *ptr = arr;
    printf("Value of first element: %d\n", *ptr);
    printf("Value of second element: %d\n", *(ptr + 1));
    return 0;
}

8. 结构体

结构体用于组合不同类型的数据。

实战案例：结构体使用

#include <stdio.h>

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

int main() {
    struct Student s1;
    strcpy(s1.name, "John");
    s1.age = 20;
    s1.marks = 85.5f;
    printf("Name: %s\n", s1.name);
    printf("Age: %d\n", s1.age);
    printf("Marks: %.2f\n", s1.marks);
    return 0;
}

9. 位运算

位运算用于操作二进制位。

实战案例：位运算

#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 << 1 = %d\n", a << 1);
    printf("a >> 1 = %d\n", a >> 1);
    return 0;
}

10. 预处理

预处理是C语言的一个特性，允许在编译前处理源代码。

实战案例：宏定义

#include <stdio.h>

#define PI 3.14159

int main() {
    printf("Value of PI: %f\n", PI);
    return 0;
}

11. 文件操作

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

实战案例：文件读取

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

12. 动态内存分配

动态内存分配允许在运行时分配内存。

实战案例：malloc和free

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

int main() {
    int *arr = (int *)malloc(5 * sizeof(int));
    if (arr == NULL) {
        printf("Error allocating memory\n");
        return 1;
    }
    for (int i = 0; i < 5; i++) {
        arr[i] = i * 2;
    }
    for (int i = 0; i < 5; i++) {
        printf("%d ", arr[i]);
    }
    free(arr);
    return 0;
}

13. 链表

链表是一种常见的数据结构，用于存储具有相同类型的数据元素。

实战案例：单链表

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

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

void insert(struct Node **head, int value) {
    struct Node *newNode = (struct Node *)malloc(sizeof(struct Node));
    newNode->data = value;
    newNode->next = *head;
    *head = newNode;
}

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

int main() {
    struct Node *head = NULL;
    insert(&head, 3);
    insert(&head, 2);
    insert(&head, 1);
    display(head);
    return 0;
}

14. 栈

栈是一种先进后出（FILO）的数据结构。

实战案例：栈的实现

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

#define MAX_SIZE 10

struct Stack {
    int top;
    int arr[MAX_SIZE];
};

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

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

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

void push(struct Stack *s, int value) {
    if (isFull(s)) {
        printf("Stack overflow\n");
        return;
    }
    s->arr[++s->top] = value;
}

int pop(struct Stack *s) {
    if (isEmpty(s)) {
        printf("Stack underflow\n");
        return -1;
    }
    return s->arr[s->top--];
}

int main() {
    struct Stack s;
    initialize(&s);
    push(&s, 10);
    push(&s, 20);
    push(&s, 30);
    printf("Popped element: %d\n", pop(&s));
    printf("Popped element: %d\n", pop(&s));
    printf("Popped element: %d\n", pop(&s));
    return 0;
}

15. 队列

队列是一种先进先出（FIFO）的数据结构。

实战案例：队列的实现

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

#define MAX_SIZE 10

struct Queue {
    int front, rear;
    int arr[MAX_SIZE];
};

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

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

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

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

int dequeue(struct Queue *q) {
    if (isEmpty(q)) {
        printf("Queue underflow\n");
        return -1;
    }
    int value = q->arr[q->front];
    if (q->front == q->rear) {
        q->front = q->rear = -1;
    } else {
        q->front = (q->front + 1) % MAX_SIZE;
    }
    return value;
}

int main() {
    struct Queue q;
    initialize(&q);
    enqueue(&q, 10);
    enqueue(&q, 20);
    enqueue(&q, 30);
    printf("Dequeued element: %d\n", dequeue(&q));
    printf("Dequeued element: %d\n", dequeue(&q));
    printf("Dequeued element: %d\n", dequeue(&q));
    return 0;
}

16. 树

树是一种非线性数据结构，用于存储具有父子关系的数据。

实战案例：二叉树

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

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

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

void insert(struct Node **root, int value) {
    if (*root == NULL) {
        *root = createNode(value);
    } else if (value < (*root)->data) {
        insert(&((*root)->left), value);
    } else {
        insert(&((*root)->right), value);
    }
}

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

int main() {
    struct Node *root = NULL;
    insert(&root, 5);
    insert(&root, 3);
    insert(&root, 7);
    insert(&root, 2);
    insert(&root, 4);
    insert(&root, 6);
    insert(&root, 8);
    printf("Inorder traversal: ");
    inorderTraversal(root);
    printf("\n");
    return 0;
}

17. 图

图是一种非线性数据结构，用于存储具有多个连接的数据。

实战案例：邻接矩阵表示的图

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

#define MAX_VERTICES 5

struct Graph {
    int numVertices;
    int adjacencyMatrix[MAX_VERTICES][MAX_VERTICES];
};

void initializeGraph(struct Graph *g, int numVertices) {
    g->numVertices = numVertices;
    for (int i = 0; i < numVertices; i++) {
        for (int j = 0; j < numVertices; j++) {
            g->adjacencyMatrix[i][j] = 0;
        }
    }
}

void addEdge(struct Graph *g, int start, int end) {
    g->adjacencyMatrix[start][end] = 1;
    g->adjacencyMatrix[end][start] = 1;
}

void displayGraph(struct Graph *g) {
    for (int i = 0; i < g->numVertices; i++) {
        for (int j = 0; j < g->numVertices; j++) {
            printf("%d ", g->adjacencyMatrix[i][j]);
        }
        printf("\n");
    }
}

int main() {
    struct Graph g;
    initializeGraph(&g, 4);
    addEdge(&g, 0, 1);
    addEdge(&g, 0, 2);
    addEdge(&g, 1, 2);
    addEdge(&g, 2, 3);
    displayGraph(&g);
    return 0;
}

18. 动态内存管理

动态内存管理是C语言中的一个重要特性，允许在运行时分配和释放内存。

实战案例：malloc和free

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

int main() {
    int *arr = (int *)malloc(5 * sizeof(int));
    if (arr == NULL) {
        printf("Error allocating memory\n");
        return 1;
    }
    for (int i = 0; i < 5; i++) {
        arr[i] = i * 2;
    }
    for (int i = 0; i < 5; i++) {
        printf("%d ", arr[i]);
    }
    free(arr);
    return 0;
}

19. 错误处理

错误处理是C语言编程中的一个重要方面，可以防止程序崩溃并提高程序的健壮性。

实战案例：错误处理

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

int main() {
    FILE *file = fopen("example.txt", "r");
    if (file == NULL) {
        perror("Error opening file");
        return 1;
    }
    char ch;
    while ((ch = fgetc(file)) != EOF) {
        printf("%c", ch);
    }
    fclose(file);
    return 0;
}

20. 静态内存分配

静态内存分配是在编译时分配内存，通常用于小型数据结构。

实战案例：静态内存分配

#include <stdio.h>

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

21. 内存泄漏

内存泄漏是C语言编程中的一个常见问题，导致程序占用越来越多的内存。

实战案例：内存泄漏

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

void func() {
    int *arr = (int *)malloc(5 * sizeof(int));
    if (arr == NULL) {
        printf("Error allocating memory\n");
        return;
    }
    // Do something with arr
    // ...
    free(arr);
}

int main() {
    func();
    // Memory leak
    return 0;
}

22. 动态内存释放

动态内存释放是在程序结束时释放已分配的内存，避免内存泄漏。

实战案例：动态内存释放

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

int main() {
    int *arr = (int *)malloc(5 * sizeof(int));
    if (arr == NULL) {
        printf("Error allocating memory\n");
        return 1;
    }
    for (int i = 0; i < 5; i++) {
        arr[i] = i * 2;
    }
    for (int i = 0; i < 5; i++) {
        printf("%d ", arr[i]);
    }
    free(arr);
    return 0;
}

23. 栈溢出

栈溢出是C语言编程中的一个常见问题，当函数调用层次太深时发生。

实战案例：栈溢出

#include <stdio.h>

void recursiveFunc(int depth) {
    if (depth > 0) {
        recursiveFunc(depth - 1);
    }
    printf("%d ", depth);
}

int main() {
    recursiveFunc(1000);
    return 0;
}

24. 栈下溢

栈下溢是C语言编程中的一个常见问题，当从栈中弹出数据时发生。

实战案例：栈下溢

#include <stdio.h>

void recursiveFunc(int depth) {
    if (depth > 0) {
        recursiveFunc(depth - 1);
    }
    printf("%d ", depth);
}

int main() {
    recursiveFunc(-1000);
    return 0;
}

25. 队列溢出

队列溢出是C语言编程中的一个常见问题，当队列已满时发生。

实战案例：队列溢出

”`c #include #include

#define MAX_SIZE 5

struct Queue {

int front, rear;
int arr[MAX_SIZE];

};

void initialize(struct Queue *q) {

q->front = q->rear = -1;

}

int isEmpty(struct Queue *q) {

return q->front == -1;

}

int isFull(struct Queue *q) {

return (q
上一问答：【掌握CSS打造完美响应式网页】揭秘布局、媒体查询与适应性设计技巧
下一问答：轻松掌握C语言，计算任意两点间的几何距离，只需几行代码！
大家都在看
问

成都华润翡翠城这个楼盘怎么样周边环境如何

发布时间：2024-12-14 02:49
成都华润翡翠城这个楼盘怎么样？周边环境如何？ 华润·翡翠城占地亩，被“一湖两河三公园环抱”，包括420亩东湖公园和780余亩的住宅用地。楼盘特征： 1、华润·翡翠?城占地1245亩，被“一湖两河三公园环抱”，包括420亩东湖公园和780。
问

古时候令牌上写的是什么

发布时间：2024-09-05 20:25
上面的文字一般是隶书楷书。并辅以云纹符篆。 令牌又名“雷令”、“五雷牌”。为圆顶平底之木牌。侧面边围刻有二十八宿的名称。上圆下方的形状，象征天地。令牌是道士差遣神灵的神圣法器，有辟邪的作用，也可用于差遣雷神。令牌的形状与图案并不完全一致，。
问

贵阳地铁1号线的建设历程

发布时间：2024-12-11 19:17
2006年10月《贵阳来市轨道交自通网络规划》初稿完成，2010年9月3日国家发改委正式下文批复贵阳城市轨道交通建设规划，2013年4月23日，《贵阳轨道交通1号线工程可行性研究报告》正式获得国家发展改革委批复；2013年9月29日，贵阳轨。
问

成都地铁的发展前景

发布时间：2024-12-10 12:24
成都地铁的建设，最直接的一点地铁为市民提供了另一种出行方式。成都的公共交通体系长期以来仅有以公交运营体系、出租车等为主的地面交通网络。地铁的出现，大大的减少了地面交通的压力，让更多的市民不要再为公交车的拥挤而烦恼。容量大、速度快、准点率高。
问

去北京的西单买衣服，从地铁哪个出口出来呀到哪个商场呀

发布时间：2024-12-11 00:18
地铁1号线的话，在B口出来离西单商业区近，奔北可以到中友、明珠、西单商场方向地铁4号线的话，从F1口出来离西单商业区近，奔北可以到君太、大悦城方向。
问

武汉协和医院地铁站是哪站

发布时间：2024-12-10 02:01
武汉市到协和医院，可以乘坐地铁二号线到中山公园站C出口，步行约400米就是。。
问

上海地铁十二号线首班车

发布时间：2024-12-11 05:19
1、上海地铁制12号线起点站首班车时间：05:30。2、末班车时间：22:17 终点站首末车时间：05:30-22:30 发车间隔：5-10分钟 全程票价（元）：7.00 。3、工作日行车间隔：（1）天潼路站~巨峰路站工作日早晚高峰行车间隔。
问

武汉地铁8号线

发布时间：2024-12-13 20:40
三金潭车辆段站、金银潭大道站、塔子湖站、幸福大道站、兴业路站、竹叶山站、赵家条站、黄浦路站、徐家棚站、徐东站、汪家墩站、岳家嘴站、梨园站。
问

生化肝功能包括哪几项

发布时间：2024-10-30 17:33
肝功能有很多，肝脏对于人体的正常运作起着不可替代的作用。每一个人都应该定期去医院检查各个器官的健康状况，一旦发现有不合格的地方，应该立即进行治疗。对于肝功能。
问

天津市地铁可以刷银行卡，在办理之前需要开通网银吗

发布时间：2024-12-10 17:54
需要的，现在办银行卡必定要开通网银，不然很麻烦。