学会C语言：轻松上手30个经典程序代码实例解析

在学习和掌握一门编程语言的过程中，通过实际操作编写代码是至关重要的。C语言作为一种历史悠久且应用广泛的编程语言，它以其高效和灵活的特点深受编程爱好者和专业人士的喜爱。本篇文章将带您通过30个经典程序代码实例，轻松上手C语言编程。

1. Hello World程序

这是一个任何编程语言的入门程序，它简单地输出“Hello, World!”到控制台。

#include <stdio.h>

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

2. 计算两个数的和

#include <stdio.h>

int main() {
    int a, b, sum;
    printf("Enter two numbers: ");
    scanf("%d %d", &a, &b);
    sum = a + b;
    printf("Sum of %d and %d is %d\n", a, b, sum);
    return 0;
}

3. 输入输出函数

学习如何使用printf和scanf函数来输入输出数据。

#include <stdio.h>

int main() {
    int num;
    printf("Enter an integer: ");
    scanf("%d", &num);
    printf("You entered: %d\n", num);
    return 0;
}

4. 判断质数

判断一个整数是否为质数的程序。

#include <stdio.h>
#include <stdbool.h>

bool is_prime(int num) {
    if (num <= 1) return false;
    for (int i = 2; i * i <= num; i++) {
        if (num % i == 0) return false;
    }
    return true;
}

int main() {
    int num;
    printf("Enter a number to check if it's a prime: ");
    scanf("%d", &num);
    if (is_prime(num)) {
        printf("%d is a prime number.\n", num);
    } else {
        printf("%d is not a prime number.\n", num);
    }
    return 0;
}

5. 使用循环计算阶乘

计算一个整数的阶乘。

#include <stdio.h>

long factorial(int num) {
    long fact = 1;
    for (int i = 1; i <= num; i++) {
        fact *= i;
    }
    return fact;
}

int main() {
    int num;
    printf("Enter a number to calculate its factorial: ");
    scanf("%d", &num);
    printf("Factorial of %d is %ld\n", num, factorial(num));
    return 0;
}

6. 查找数组中的最大值

#include <stdio.h>

int main() {
    int arr[] = {3, 6, 2, 8, 4, 7};
    int max = arr[0];
    for (int i = 1; i < sizeof(arr) / sizeof(arr[0]); i++) {
        if (arr[i] > max) {
            max = arr[i];
        }
    }
    printf("Maximum element in the array is %d\n", max);
    return 0;
}

7. 二维数组

初始化并打印一个二维数组。

#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("%d ", arr[i][j]);
        }
        printf("\n");
    }
    return 0;
}

8. 函数指针

使用函数指针作为参数的函数示例。

#include <stdio.h>

void add(int a, int b) {
    printf("%d + %d = %d\n", a, b, a + b);
}

void multiply(int a, int b) {
    printf("%d * %d = %d\n", a, b, a * b);
}

void operate(int a, int b, void (*op)(int, int)) {
    op(a, b);
}

int main() {
    operate(3, 4, add);
    operate(3, 4, multiply);
    return 0;
}

9. 链表

实现一个简单的单链表并插入新节点。

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

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

void insertAtHead(struct Node** head_ref, int new_data) {
    struct Node* new_node = (struct Node*)malloc(sizeof(struct Node));
    new_node->data = new_data;
    new_node->next = (*head_ref);
    (*head_ref) = new_node;
}

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

int main() {
    struct Node* head = NULL;
    insertAtHead(&head, 3);
    insertAtHead(&head, 2);
    insertAtHead(&head, 1);
    printf("Created linked list is: ");
    printList(head);
    return 0;
}

10. 文件操作

使用C语言编写一个简单的文件读写程序。

#include <stdio.h>

int main() {
    FILE *file = fopen("example.txt", "w");
    if (file == NULL) {
        perror("Error opening file");
        return 1;
    }
    fprintf(file, "This is a test.\n");
    fclose(file);

    file = fopen("example.txt", "r");
    if (file == NULL) {
        perror("Error opening file");
        return 1;
    }
    char c;
    while ((c = fgetc(file)) != EOF) {
        putchar(c);
    }
    fclose(file);
    return 0;
}

11. 字符串处理

字符串反转的程序。

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

void reverse(char *str) {
    int len = strlen(str);
    for (int i = 0; i < len / 2; i++) {
        char temp = str[i];
        str[i] = str[len - i - 1];
        str[len - i - 1] = temp;
    }
}

int main() {
    char str[100];
    printf("Enter a string: ");
    fgets(str, 100, stdin);
    str[strcspn(str, "\n")] = 0; // Remove newline character
    reverse(str);
    printf("Reversed string: %s\n", str);
    return 0;
}

12. 结构体和联合体

使用结构体存储学生的信息，并打印出来。

#include <stdio.h>

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

void printStudent(const Student *s) {
    printf("Name: %s, Age: %d, GPA: %.2f\n", s->name, s->age, s->gpa);
}

int main() {
    Student s = {"Alice", 22, 3.5};
    printStudent(&s);
    return 0;
}

13. 动态内存分配

使用malloc和free来动态分配和释放内存。

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

int main() {
    int* ptr = (int*)malloc(sizeof(int));
    if (ptr == NULL) {
        fprintf(stderr, "Memory allocation failed\n");
        return 1;
    }
    *ptr = 42;
    printf("Value: %d\n", *ptr);
    free(ptr);
    return 0;
}

14. 错误处理

处理函数中的错误情况。

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

int divide(int a, int b) {
    if (b == 0) {
        fprintf(stderr, "Division by zero is undefined.\n");
        exit(EXIT_FAILURE);
    }
    return a / b;
}

int main() {
    int a = 10, b = 0;
    printf("Result: %d\n", divide(a, b));
    return 0;
}

15. 递归

使用递归函数计算阶乘。

#include <stdio.h>

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

int main() {
    int num;
    printf("Enter a number to calculate its factorial: ");
    scanf("%d", &num);
    printf("Factorial of %d is %ld\n", num, factorial(num));
    return 0;
}

16. 位运算

使用位运算来设置、清除和测试一个数的特定位。

#include <stdio.h>

void setBit(int num, int bitPosition) {
    num |= (1 << bitPosition);
    printf("Number after setting bit %d: %d\n", bitPosition, num);
}

void clearBit(int num, int bitPosition) {
    num &= ~(1 << bitPosition);
    printf("Number after clearing bit %d: %d\n", bitPosition, num);
}

int testBit(int num, int bitPosition) {
    return (num & (1 << bitPosition)) != 0;
}

int main() {
    int num = 0b00001111;
    setBit(num, 2);
    clearBit(num, 3);
    if (testBit(num, 1)) {
        printf("Bit 1 is set.\n");
    } else {
        printf("Bit 1 is not set.\n");
    }
    return 0;
}

17. 排序算法

实现冒泡排序算法对数组进行排序。

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

18. 二叉树

实现一个简单的二叉树并插入新节点。

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

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

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

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

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

int main() {
    struct Node* root = NULL;
    insert(&root, 50);
    insert(&root, 30);
    insert(&root, 20);
    insert(&root, 40);
    insert(&root, 70);
    insert(&root, 60);
    insert(&root, 80);
    printf("Inorder traversal of the binary tree is:\n");
    printInOrder(root);
    return 0;
}

19. 线程

创建一个简单的多线程程序。

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

void* threadFunction(void* arg) {
    int threadId = *(int*)arg;
    printf("Thread ID: %d\n", threadId);
    free(arg);
    return NULL;
}

int main() {
    int* tid;
    pthread_t thread;
    tid = malloc(sizeof(int));
    *tid = 1234;
    if (pthread_create(&thread, NULL, threadFunction, tid) != 0) {
        perror("Failed to create thread");
        return 1;
    }
    pthread_join(thread, NULL);
    return 0;
}

20. 网络编程

一个简单的TCP客户端，向服务器发送数据。

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <unistd.h>

int main() {
    int sockfd, portno, n;
    struct sockaddr_in serv_addr;
    char buffer[256];

    portno = 8080;
    sockfd = socket(AF_INET, SOCK_STREAM, 0);
    if (sockfd < 0) {
        perror("Error opening socket");
        return 1;
    }
    bzero((char *)&serv_addr, sizeof(serv_addr));
    serv_addr.sin_family = AF_INET;
    serv_addr.sin_port = htons(portno);

    if (inet_pton(AF_INET, "127.0.0.1", &serv_addr.sin_addr) <= 0) {
        perror("Invalid address/ Address not supported");
        return 1;
    }

    if (connect(sockfd, (struct sockaddr *)&serv_addr, sizeof(serv_addr)) < 0) {
        perror("Connection Failed");
        return 1;
    }

    printf("Please enter the message: ");
    fgets(buffer, 255, stdin);
    n = write(sockfd, buffer, strlen(buffer));
    if (n < 0) {
        perror("Write Error");
        return 1;
    }

    bzero(buffer, 256);
    n = read(sockfd, buffer, 255);
    if (n < 0) {
        perror("Read Error");
        return 1;
    }
    printf("Message from server: %s\n", buffer);
    close(sockfd);
    return 0;
}

21. 数据结构 - 队列

实现一个循环队列。

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

#define QUEUE_SIZE 5

typedef struct {
    int items[QUEUE_SIZE];
    int front;
    int rear;
    int size;
} Queue;

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

int isEmpty(Queue *q) {
    return (q->size == 0);
}

int isFull(Queue *q) {
    return (q->size == QUEUE_SIZE);
}

void enqueue(Queue *q, int item) {
    if (isFull(q)) {
        printf("Queue is full.\n");
        return;
    }
    q->rear = (q->rear + 1) % QUEUE_SIZE;
    q->items[q->rear] = item;
    q->size++;
}

int dequeue(Queue *q) {
    if (isEmpty(q)) {
        printf("Queue is empty.\n");
        return -1;
    }
    int item = q->items[q->front];
    q->front = (q->front + 1) % QUEUE_SIZE;
    q->size--;
    return item;
}

int main() {
    Queue q;
    initialize(&q);

    enqueue(&q, 10);
    enqueue(&q, 20);
    enqueue(&q, 30);

    printf("Dequeued item: %d\n", dequeue(&q));
    printf("Dequeued item: %d\n", dequeue(&q));

    return 0;
}

22. 数据结构 - 栈

实现一个动态数组作为栈。

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

typedef struct {
    int *array;
    int top;
    int capacity;
} Stack;

Stack* createStack(int capacity) {
    Stack *stack = (Stack*)malloc(sizeof(Stack));
    stack->capacity = capacity;
    stack->top = -1;
    stack->array = (int*)malloc(stack->capacity * sizeof(int));
    return stack;
}

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

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

void push(Stack *stack, int item) {
    if (isFull(stack)) {
        return;
    }
    stack->array[++stack->top] = item;
}

int pop(Stack *stack) {
    if (isEmpty(stack)) {
        return -1;
    }
    return stack->array[stack->top--];
}

int peek(Stack *stack) {
    if (isEmpty(stack)) {
        return -1;
    }
    return stack->array[stack->top];
}

void deleteStack(Stack *stack) {
    free(stack->array);
    free(stack);
}

int main() {
    Stack *stack = createStack(5);
    push(stack, 10);
    push(stack, 20);
    push(stack, 30);
    printf("Peek: %d\n", peek(stack));
    printf("Popped: %d\n", pop(stack));
    printf("Popped: %d\n", pop(stack));
    deleteStack(stack);
    return 0;
}

23. 数据结构 - 链表

实现一个简单的单向链表，并在链表末尾插入新节点。

”`c #include #include

struct Node {

int data;
struct Node* next;

};

struct Node* createNode(int value) {

struct Node* newNode = (struct Node*)malloc(sizeof(struct Node));
newNode->data = value;
newNode->next = NULL;
return newNode;

}

void append(struct Node** head_ref, int new_data) {

struct Node* newNode = createNode(new_data);
if (*head_ref == NULL) {
    *head_ref = newNode;
    return;
}
struct Node* last = *head_ref;
while (last->next != NULL) {
    last = last->next;
}
last->next = newNode;

}

void printList(struct Node

正文

学会C语言：轻松上手30个经典程序代码实例解析

1. Hello World程序

2. 计算两个数的和

3. 输入输出函数

4. 判断质数

5. 使用循环计算阶乘

6. 查找数组中的最大值

7. 二维数组

8. 函数指针

9. 链表

10. 文件操作

11. 字符串处理

12. 结构体和联合体

13. 动态内存分配

14. 错误处理

15. 递归

16. 位运算

17. 排序算法

18. 二叉树

19. 线程

20. 网络编程

21. 数据结构 - 队列

22. 数据结构 - 栈

23. 数据结构 - 链表

相关阅读

C语言编程常见错误分析与解题技巧详解

掌握C语言，轻松解程序例题：常见题型解析与实战演练

破解C语言数组难题，50个实战例题帮你轻松入门！

C语言入门必备：经典顺序结构程序题解析与实战

C语言入门必备：轻松学会累乘法，附带实用例题解析

学会C语言编程，从这些简单例题开始入门

掌握C语言，破解经典程序难题，入门到精通的实用指南

C语言编程入门：轻松学会例题解析，提升编程技巧

从零开始：C语言例题解析与实用程序代码展示

破解C语言难题：轻松解读经典程序例题，助你提升编程技巧