C语言编程入门：30个实用实例解析，助你轻松掌握编程技巧

实例1：Hello World程序

介绍

Hello World程序是每个编程初学者都会写的第一个程序。它简单易懂，能够帮助你熟悉C语言的基本语法。

代码

#include <stdio.h>

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

说明

这个程序使用了printf函数来输出字符串”Hello, World!“。

实例2：变量声明与赋值

介绍

变量是存储数据的地方。在C语言中，我们需要声明变量并为其赋值。

代码

#include <stdio.h>

int main() {
    int age = 20;
    printf("My age is: %d\n", age);
    return 0;
}

说明

这个程序声明了一个整型变量age，并给它赋值为20，然后输出这个值。

实例3：数据类型转换

介绍

C语言支持多种数据类型，有时我们需要将一个数据类型转换为另一个数据类型。

代码

#include <stdio.h>

int main() {
    int num = 10;
    float result = (float)num;
    printf("The result is: %f\n", result);
    return 0;
}

说明

这个程序将整型变量num转换为浮点型，并输出转换后的结果。

实例4：条件语句

介绍

条件语句用于根据条件判断执行不同的代码块。

代码

#include <stdio.h>

int main() {
    int num = 10;
    if (num > 5) {
        printf("The number is greater than 5.\n");
    } else {
        printf("The number is not greater than 5.\n");
    }
    return 0;
}

说明

这个程序根据变量num的值判断是否大于5，并输出相应的信息。

实例5：循环语句

介绍

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

代码

#include <stdio.h>

int main() {
    int i;
    for (i = 1; i <= 5; i++) {
        printf("The number is: %d\n", i);
    }
    return 0;
}

说明

这个程序使用for循环打印从1到5的数字。

实例6：函数调用

介绍

函数是C语言中的基本组成部分，它允许我们将代码分成多个模块。

代码

#include <stdio.h>

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

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

说明

这个程序定义了一个名为printMessage的函数，并在main函数中调用它。

实例7：数组操作

介绍

数组是存储多个相同类型数据的集合。

代码

#include <stdio.h>

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

说明

这个程序声明了一个整型数组numbers，并计算它的元素之和。

实例8：指针操作

介绍

指针是C语言中的一个重要概念，它允许我们直接访问内存地址。

代码

#include <stdio.h>

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

说明

这个程序声明了一个整型变量num和一个指向它的指针ptr，然后输出num的值。

实例9：结构体

介绍

结构体允许我们将不同类型的数据组合在一起。

代码

#include <stdio.h>

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

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

说明

这个程序定义了一个名为Person的结构体，并创建了一个Person类型的变量person，然后输出它的信息。

实例10：文件操作

介绍

文件操作是C语言中的一个重要方面，它允许我们读写文件。

代码

#include <stdio.h>

int main() {
    FILE *file = fopen("example.txt", "w");
    if (file == NULL) {
        printf("Error opening file.\n");
        return 1;
    }
    fprintf(file, "Hello, World!\n");
    fclose(file);
    return 0;
}

说明

这个程序创建并打开一个名为example.txt的文件，写入字符串”Hello, World!“，然后关闭文件。

实例11：字符串处理

介绍

字符串是C语言中的一种特殊数据类型，用于存储字符序列。

代码

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

int main() {
    char str1[50] = "Hello";
    char str2[50] = "World";
    strcat(str1, str2);
    printf("Concatenated string: %s\n", str1);
    return 0;
}

说明

这个程序使用strcat函数将两个字符串连接起来，并输出结果。

实例12：动态内存分配

介绍

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

代码

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

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

说明

这个程序使用malloc函数动态分配了一个整型数组，并初始化它的元素，然后输出这些元素。

实例13：结构体数组

介绍

结构体数组允许我们将多个结构体实例存储在一个数组中。

代码

#include <stdio.h>

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

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

说明

这个程序声明了一个名为people的结构体数组，并初始化了它的元素，然后输出这些元素的信息。

实例14：指针数组

介绍

指针数组允许我们将多个指针存储在一个数组中。

代码

#include <stdio.h>

int main() {
    int a = 10, b = 20;
    int *ptrs[2] = {&a, &b};
    for (int i = 0; i < 2; i++) {
        printf("Value: %d\n", *ptrs[i]);
    }
    return 0;
}

说明

这个程序声明了一个整型指针数组ptrs，并初始化了它的元素，然后输出这些指针指向的值。

实例15：函数指针

介绍

函数指针允许我们将函数作为参数传递。

代码

#include <stdio.h>

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

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

说明

这个程序定义了一个名为printMessage的函数，并将其地址赋给一个函数指针funcPtr，然后调用这个指针。

实例16：递归函数

介绍

递归函数是一种调用自身的函数。

代码

#include <stdio.h>

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

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

说明

这个程序定义了一个名为factorial的递归函数，用于计算一个数的阶乘。

实例17：指针与数组

介绍

指针与数组是C语言中的基本概念，它们经常一起使用。

代码

#include <stdio.h>

int main() {
    int arr[5] = {1, 2, 3, 4, 5};
    int *ptr = arr;
    for (int i = 0; i < 5; i++) {
        printf("Value at index %d: %d\n", i, *(ptr + i));
    }
    return 0;
}

说明

这个程序使用指针访问数组元素，并输出它们的值。

实例18：指针与字符串

介绍

指针与字符串是C语言中的基本概念，它们经常一起使用。

代码

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

int main() {
    char str1[50] = "Hello";
    char str2[50] = "World";
    char *ptr1 = str1;
    char *ptr2 = str2;
    printf("Length of str1: %d\n", strlen(ptr1));
    printf("Length of str2: %d\n", strlen(ptr2));
    return 0;
}

说明

这个程序使用指针访问字符串，并输出它们的长度。

实例19：结构体指针

介绍

结构体指针允许我们通过指针访问结构体成员。

代码

#include <stdio.h>

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

int main() {
    struct Person person;
    strcpy(person.name, "John");
    person.age = 25;
    struct Person *ptr = &person;
    printf("Name: %s, Age: %d\n", ptr->name, ptr->age);
    return 0;
}

说明

这个程序使用结构体指针访问结构体成员，并输出它们的信息。

实例20：函数指针与结构体

介绍

函数指针与结构体允许我们将函数作为结构体的成员。

代码

#include <stdio.h>

struct Person {
    char name[50];
    int age;
    void (*printInfo)(struct Person);
};

void printPersonInfo(struct Person person) {
    printf("Name: %s, Age: %d\n", person.name, person.age);
}

int main() {
    struct Person person;
    strcpy(person.name, "John");
    person.age = 25;
    person.printInfo = printPersonInfo;
    person.printInfo(person);
    return 0;
}

说明

这个程序定义了一个名为Person的结构体，它包含一个指向函数的指针printInfo。然后，我们创建了一个Person实例，并调用它的printInfo成员函数。

实例21：文件读写

介绍

文件读写是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, sizeof(buffer), file)) {
        printf("%s", buffer);
    }
    fclose(file);
    return 0;
}

说明

这个程序打开一个名为example.txt的文件，并逐行读取它的内容，然后输出这些内容。

实例22：字符串搜索

介绍

字符串搜索是C语言中的一个重要方面，它允许我们在一个字符串中查找另一个字符串。

代码

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

int main() {
    char str1[50] = "Hello, World!";
    char str2[50] = "World";
    int index = strstr(str1, str2) - str1;
    printf("Index of '%s' in '%s': %d\n", str2, str1, index);
    return 0;
}

说明

这个程序使用strstr函数在字符串str1中搜索字符串str2，并输出搜索到的索引。

实例23：字符串替换

介绍

字符串替换是C语言中的一个重要方面，它允许我们在一个字符串中替换指定的子字符串。

代码

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

void replaceSubstring(char *str, const char *old, const char *new) {
    char buffer[1024];
    char *pos;
    while ((pos = strstr(str, old)) != NULL) {
        strncpy(buffer, str, pos - str);
        buffer[pos - str] = '\0';
        strcat(buffer, new);
        strcat(buffer, str + pos - str + strlen(old));
        strcpy(str, buffer);
    }
}

int main() {
    char str[50] = "Hello, World!";
    replaceSubstring(str, "World", "C");
    printf("Modified string: %s\n", str);
    return 0;
}

说明

这个程序定义了一个名为replaceSubstring的函数，用于替换字符串中的子字符串，并在main函数中调用它。

实例24：字符串排序

介绍

字符串排序是C语言中的一个重要方面，它允许我们按特定顺序排列字符串。

代码

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

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

int main() {
    char *strings[] = {"C", "C++", "Java", "Python"};
    int n = sizeof(strings) / sizeof(strings[0]);
    sortStrings(strings, n);
    for (int i = 0; i < n; i++) {
        printf("%s\n", strings[i]);
    }
    return 0;
}

说明

这个程序定义了一个名为sortStrings的函数，用于对字符串数组进行排序，并在main函数中调用它。

实例25：链表操作

介绍

链表是C语言中的一个重要数据结构，它允许我们动态地存储和访问数据。

代码

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

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

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

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

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

说明

这个程序定义了一个名为Node的结构体，用于创建链表节点，并实现了在链表头部插入新节点和打印链表的功能。

实例26：栈操作

介绍

栈是一种后进先出（LIFO）的数据结构，它允许我们存储和访问数据。

代码

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

#define MAX_SIZE 100

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

void initializeStack(struct Stack *stack) {
    stack->top = -1;
}

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

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

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

int pop(struct Stack *stack) {
    if (isEmpty(stack)) {
        printf("Stack is empty.\n");
        return -1;
    }
    return stack->items[stack->top--];
}

int main() {
    struct Stack stack;
    initializeStack(&stack);
    push(&stack, 1);
    push(&stack, 2);
    push(&stack, 3);
    printf("Popped item: %d\n", pop(&stack));
    printf("Popped item: %d\n", pop(&stack));
    printf("Popped item: %d\n", pop(&stack));
    return 0;
}

说明

这个程序定义了一个名为Stack的结构体，用于创建栈，并实现了初始化、判断是否为空、判断是否已满、入栈和出栈的功能。

实例27：队列操作

介绍

队列是一种先进先出（FIFO）的数据结构，它允许我们存储和访问数据。

代码

”`c #include #include

#define MAX_SIZE 100

struct Queue {

int front, rear;
int items[MAX_SIZE];

};

void initializeQueue(struct Queue *queue) {

queue->front = queue->rear = -1;

}

int isEmpty(struct Queue *queue) {

return queue->