C语言编程入门：30个实用实例解析，从基础到实战！

实例1：打印“Hello, World!”

C语言编程的第一步通常是打印一个简单的问候语。这是一个基础的输出操作，用于验证编译器是否正常工作。

#include <stdio.h>

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

实例2：变量与赋值

变量是存储数据的地方。在这个例子中，我们将创建一个变量来存储一个整数，并打印它的值。

#include <stdio.h>

int main() {
    int number = 10;
    printf("The value of number is: %d\n", number);
    return 0;
}

实例3：数据类型

C语言有多种数据类型，如整数、浮点数和字符。这个例子展示了如何使用不同的数据类型。

#include <stdio.h>

int main() {
    int num = 5;
    float fnum = 5.5;
    char letter = 'A';
    printf("Integer: %d\n", num);
    printf("Float: %f\n", fnum);
    printf("Character: %c\n", letter);
    return 0;
}

实例4：运算符

C语言中的运算符用于执行数学和逻辑运算。这个例子演示了基本的算术运算符。

#include <stdio.h>

int main() {
    int a = 10, b = 5;
    printf("Sum: %d\n", a + b);
    printf("Difference: %d\n", a - b);
    printf("Product: %d\n", a * b);
    printf("Quotient: %d\n", a / b);
    printf("Modulus: %d\n", a % b);
    return 0;
}

实例5：控制流——if语句

if语句用于基于条件执行代码块。这个例子展示了如何使用if语句来判断一个数是否为正数。

#include <stdio.h>

int main() {
    int number = 7;
    if (number > 0) {
        printf("The number is positive.\n");
    } else {
        printf("The number is not positive.\n");
    }
    return 0;
}

实例6：循环——for循环

for循环用于重复执行一个代码块。这个例子展示了如何使用for循环来打印1到10的数字。

#include <stdio.h>

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

实例7：循环——while循环

while循环用于在满足特定条件时重复执行代码块。这个例子展示了如何使用while循环来计算1到10的和。

#include <stdio.h>

int main() {
    int i = 1, sum = 0;
    while (i <= 10) {
        sum += i;
        i++;
    }
    printf("Sum of numbers from 1 to 10 is: %d\n", sum);
    return 0;
}

实例8：数组

数组是存储多个相同类型数据元素的集合。这个例子展示了如何创建和使用一个整数数组。

#include <stdio.h>

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

实例9：指针

指针是存储变量地址的变量。这个例子展示了如何使用指针来访问和修改变量的值。

#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 *)&x);
    printf("Value pointed by ptr: %d\n", *ptr);
    *ptr = 20;
    printf("New value of x: %d\n", x);
    return 0;
}

实例10：函数

函数是组织代码的模块，可以重复使用。这个例子展示了如何创建和使用一个简单的函数。

#include <stdio.h>

void printMessage() {
    printf("Hello, this is a function!\n");
}

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

实例11：结构体

结构体是自定义的数据类型，可以包含不同类型的数据。这个例子展示了如何创建和使用一个结构体。

#include <stdio.h>

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

int main() {
    Person p;
    strcpy(p.name, "John Doe");
    p.age = 30;
    printf("Name: %s\n", p.name);
    printf("Age: %d\n", p.age);
    return 0;
}

实例12：动态内存分配

动态内存分配允许在运行时分配内存。这个例子展示了如何使用malloc和free函数。

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

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

实例13：文件操作

文件操作允许读写文件。这个例子展示了如何创建、写入和读取一个文件。

#include <stdio.h>

int main() {
    FILE *file = fopen("example.txt", "w");
    if (file == NULL) {
        printf("Failed to open file\n");
        return 1;
    }
    fprintf(file, "Hello, this is a test file.\n");
    fclose(file);

    file = fopen("example.txt", "r");
    if (file == NULL) {
        printf("Failed to open file\n");
        return 1;
    }
    char buffer[100];
    while (fgets(buffer, 100, file)) {
        printf("%s", buffer);
    }
    fclose(file);
    return 0;
}

实例14：字符串操作

C语言提供了多种字符串操作函数。这个例子展示了如何使用strlen和strcpy函数。

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

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

实例15：结构体数组

结构体数组可以存储多个结构体实例。这个例子展示了如何创建和使用一个结构体数组。

#include <stdio.h>

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

int main() {
    Person people[3] = {
        {"John Doe", 30},
        {"Jane Smith", 25},
        {"Alice Johnson", 28}
    };
    for (int i = 0; i < 3; i++) {
        printf("Name: %s, Age: %d\n", people[i].name, people[i].age);
    }
    return 0;
}

实例16：函数指针

函数指针是指向函数的指针。这个例子展示了如何使用函数指针。

#include <stdio.h>

void printMessage() {
    printf("Hello, this is a function!\n");
}

int main() {
    void (*funcPtr)() = printMessage;
    funcPtr();
    return 0;
}

实例17：递归函数

递归函数是在函数内部调用自身。这个例子展示了如何使用递归函数计算阶乘。

#include <stdio.h>

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

int main() {
    int num = 5;
    printf("Factorial of %d is %d\n", num, factorial(num));
    return 0;
}

实例18：宏定义

宏定义是替换文本的占位符。这个例子展示了如何使用宏定义。

#include <stdio.h>

#define PI 3.14159

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

实例19：条件编译

条件编译允许根据条件编译或跳过代码块。这个例子展示了如何使用条件编译。

#include <stdio.h>

#define DEBUG

int main() {
#ifdef DEBUG
    printf("Debug mode is enabled\n");
#endif
    return 0;
}

实例20：预处理器指令

预处理器指令在编译前处理源代码。这个例子展示了如何使用预处理器指令。

#include <stdio.h>

#define MAX(a, b) ((a) > (b) ? (a) : (b))

int main() {
    int x = 10, y = 20;
    printf("Max of %d and %d is %d\n", x, y, MAX(x, y));
    return 0;
}

实例21：位操作

位操作直接在位级别上操作数字。这个例子展示了如何使用位操作。

#include <stdio.h>

int main() {
    int a = 5; // 0101
    int b = 3; // 0011
    printf("a & b: %d\n", a & b); // 0001
    printf("a | b: %d\n", a | b); // 0111
    printf("a ^ b: %d\n", a ^ b); // 0110
    printf("a << 1: %d\n", a << 1); // 1010
    printf("a >> 1: %d\n", a >> 1); // 0101
    return 0;
}

实例22：结构体与指针

结构体与指针可以一起使用来操作复杂的数据结构。这个例子展示了如何使用结构体指针。

#include <stdio.h>

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

int main() {
    Person p = {"John Doe", 30};
    Person *ptr = &p;
    printf("Name: %s, Age: %d\n", ptr->name, ptr->age);
    (*ptr).age = 35;
    printf("New Age: %d\n", ptr->age);
    return 0;
}

实例23：链表

链表是一种动态数据结构，由节点组成，每个节点包含数据和指向下一个节点的指针。这个例子展示了如何创建和使用一个单链表。

#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 insertNode(Node **head, int data) {
    Node *newNode = createNode(data);
    if (*head == NULL) {
        *head = newNode;
    } else {
        Node *current = *head;
        while (current->next != NULL) {
            current = current->next;
        }
        current->next = newNode;
    }
}

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

int main() {
    Node *head = NULL;
    insertNode(&head, 1);
    insertNode(&head, 2);
    insertNode(&head, 3);
    printList(head);
    return 0;
}

实例24：树

树是一种非线性数据结构，由节点组成，每个节点可以有零个或多个子节点。这个例子展示了如何创建和使用一个二叉树。

#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 printInOrder(Node *root) {
    if (root != NULL) {
        printInOrder(root->left);
        printf("%d ", root->data);
        printInOrder(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("In-order traversal: ");
    printInOrder(root);
    printf("\n");
    return 0;
}

实例25：排序算法

排序算法用于将数据元素按照特定顺序排列。这个例子展示了如何实现冒泡排序算法。

#include <stdio.h>

void bubbleSort(int arr[], int n) {
    for (int i = 0; i < n - 1; i++) {
        for (int j = 0; j < n - 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[] = {64, 34, 25, 12, 22, 11, 90};
    int n = sizeof(arr) / sizeof(arr[0]);
    bubbleSort(arr, n);
    printf("Sorted array: \n");
    for (int i = 0; i < n; i++) {
        printf("%d ", arr[i]);
    }
    printf("\n");
    return 0;
}

实例26：查找算法

查找算法用于在数据结构中查找特定元素。这个例子展示了如何实现二分查找算法。

#include <stdio.h>

int binarySearch(int arr[], int l, int r, int x) {
    while (l <= r) {
        int m = l + (r - l) / 2;
        if (arr[m] == x) {
            return m;
        } else if (arr[m] < x) {
            l = m + 1;
        } else {
            r = m - 1;
        }
    }
    return -1;
}

int main() {
    int arr[] = {2, 3, 4, 10, 40};
    int n = sizeof(arr) / sizeof(arr[0]);
    int x = 10;
    int result = binarySearch(arr, 0, n - 1, x);
    if (result == -1) {
        printf("Element is not present in array\n");
    } else {
        printf("Element is present at index %d\n", result);
    }
    return 0;
}

实例27：递归算法

递归算法是使用自身调用的函数。这个例子展示了如何使用递归算法计算斐波那契数列。

#include <stdio.h>

int fibonacci(int n) {
    if (n <= 1) {
        return n;
    } else {
        return fibonacci(n - 1) + fibonacci(n - 2);
    }
}

int main() {
    int n = 10;
    printf("Fibonacci series up to %d:\n", n);
    for (int i = 0; i < n; i++) {
        printf("%d ", fibonacci(i));
    }
    printf("\n");
    return 0;
}

实例28：字符串匹配算法

字符串匹配算法用于在字符串中查找子字符串。这个例子展示了如何实现KMP算法。

”`c #include

void computeLPSArray(char* pat, int M, int* lps) {

int len = 0;
lps[0] = 0;
int i = 1;
while (i < M) {
    if (pat[i] == pat[len]) {
        len++;
        lps[i] = len;
        i++;
    } else {
        if (len != 0) {
            len = lps[len - 1];
        } else {
            lps[i] = 0;
            i++;
        }
    }
}

}

void KMPSearch(char* pat, char* txt) {

int M = strlen(pat);
int N = strlen(txt);

int lps[M];
computeLPSArray(pat, M, lps);

int i = 0; // index for txt[]
int j = 0; // index for pat[]
while (i < N) {
    if (pat[j] == txt[i]) {
        j++;
        i++;
    }
    if (j == M) {
        printf("Found pattern at index %d\n", i - j);
        j = lps[j - 1];
    } else if (i < N && pat[j] != txt[i]) {
        if (j != 0) {
            j = lps[j - 1];
        } else