破解C语言指针难题：50个实战习题，助你精通指针编程

引言

C语言中的指针是高级编程的基础，它允许程序员直接操作内存，进行高效的内存管理。然而，指针也是C语言中最容易出错和难以理解的部分之一。本文将提供50个实战习题，旨在帮助你通过练习精通指针编程。

习题一：指针的基本概念

定义一个整型变量a，然后声明一个指向a的指针pa，并通过指针访问a的值。

#include <stdio.h>

int main() {
    int a = 10;
    int *pa = &a;
    printf("Value of a through pointer: %d\n", *pa);
    return 0;
}

习题二：指针与数组

声明一个整型数组arr，然后通过指针遍历数组，打印每个元素的值。

#include <stdio.h>

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

习题三：指针算术

声明一个指向整型的指针p，初始化指向a，然后将指针移动到b的位置。

#include <stdio.h>

int main() {
    int a = 10, b = 20;
    int *p = &a;
    p = &b; // Move pointer to b
    printf("Value of b: %d\n", *p);
    return 0;
}

习题四：指针与函数

编写一个函数，使用指针参数交换两个整数的值。

#include <stdio.h>

void swap(int *x, int *y) {
    int temp = *x;
    *x = *y;
    *y = temp;
}

int main() {
    int x = 10, y = 20;
    swap(&x, &y);
    printf("x = %d, y = %d\n", x, y);
    return 0;
}

习题五：指针与字符串

编写一个函数，使用指针参数复制一个字符串。

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

void strcpy_ptr(char *dest, const char *src) {
    while (*src) {
        *dest++ = *src++;
    }
    *dest = '\0';
}

int main() {
    char src[] = "Hello, World!";
    char dest[50];
    strcpy_ptr(dest, src);
    printf("Copied string: %s\n", dest);
    return 0;
}

习题六：指针与结构体

定义一个结构体，然后创建一个结构体实例，并通过指针访问其成员。

#include <stdio.h>

typedef struct {
    int x;
    float y;
} Point;

int main() {
    Point p = {1, 2.5f};
    Point *ptr = &p;
    printf("Point x: %d, y: %f\n", ptr->x, ptr->y);
    return 0;
}

习题七：指针与动态内存分配

使用malloc和free函数分配和释放内存。

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

int main() {
    int *ptr = (int *)malloc(sizeof(int));
    if (ptr != NULL) {
        *ptr = 10;
        printf("Value: %d\n", *ptr);
        free(ptr);
    }
    return 0;
}

习题八：指针与函数指针

定义一个函数指针，并使用它调用一个函数。

#include <stdio.h>

void print_message(const char *message) {
    printf("Message: %s\n", message);
}

int main() {
    void (*func_ptr)(const char *) = print_message;
    func_ptr("Hello, World!");
    return 0;
}

习题九：指针与递归

使用指针和递归计算斐波那契数列。

#include <stdio.h>

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

int main() {
    int n = 10;
    printf("Fibonacci of %d is %d\n", n, fibonacci(n));
    return 0;
}

习题十：指针与结构体指针数组

创建一个结构体指针数组，并初始化。

#include <stdio.h>

typedef struct {
    int x;
    float y;
} Point;

int main() {
    Point points[3] = {{1, 2.5f}, {3, 4.5f}, {5, 6.5f}};
    Point *ptr_array[3];
    for (int i = 0; i < 3; i++) {
        ptr_array[i] = &points[i];
    }
    printf("Point 1: x = %d, y = %f\n", (*ptr_array[0]).x, (*ptr_array[0]).y);
    return 0;
}

习题十一：指针与函数指针数组

创建一个函数指针数组，并使用它调用不同的函数。

#include <stdio.h>

void print_int(int num) {
    printf("Integer: %d\n", num);
}

void print_float(float num) {
    printf("Float: %f\n", num);
}

int main() {
    void (*func_ptr_array[2])(int) = {print_int, print_float};
    func_ptr_array[0](10);
    func_ptr_array[1](3.14f);
    return 0;
}

习题十二：指针与多级指针

使用多级指针访问结构体成员。

#include <stdio.h>

typedef struct {
    int x;
    struct {
        int y;
        int z;
    } nested;
} ComplexStruct;

int main() {
    ComplexStruct cs = {1, {2, 3}};
    int *ptr = &cs.nested.y;
    printf("Nested y: %d\n", *ptr);
    return 0;
}

习题十三：指针与函数指针类型转换

将函数指针转换为不同的函数指针类型。

#include <stdio.h>

void print_int(int num) {
    printf("Integer: %d\n", num);
}

void print_float(float num) {
    printf("Float: %f\n", num);
}

int main() {
    void (*func_ptr_int)(int) = print_int;
    void (*func_ptr_float)(float) = print_float;
    func_ptr_int = (void (*)(float))func_ptr_float; // Type casting
    func_ptr_int(3.14f);
    return 0;
}

习题十四：指针与内存对齐

分析结构体成员的内存对齐问题。

#include <stdio.h>
#include <stdint.h>

typedef struct {
    int32_t a;
    int8_t b;
    int16_t c;
} AlignStruct;

int main() {
    printf("Size of AlignStruct: %zu\n", sizeof(AlignStruct));
    return 0;
}

习题十五：指针与位字段

使用位字段定义一个结构体，并通过指针操作位字段。

#include <stdio.h>

typedef struct {
    uint8_t a : 3;
    uint8_t b : 5;
    uint8_t c : 5;
} BitFieldStruct;

int main() {
    BitFieldStruct bfs = {0, 0, 0};
    bfs.a = 7; // Set bits in a
    printf("Bits in a: %d\n", bfs.a);
    return 0;
}

习题十六：指针与函数参数传递

比较通过值传递和指针传递参数对函数行为的影响。

#include <stdio.h>

void modify_value(int value) {
    value = 20;
}

void modify_pointer(int *ptr) {
    *ptr = 20;
}

int main() {
    int x = 10;
    modify_value(x);
    printf("x after modify_value: %d\n", x); // x remains 10

    modify_pointer(&x);
    printf("x after modify_pointer: %d\n", x); // x becomes 20
    return 0;
}

习题十七：指针与动态内存分配与释放

动态分配内存，使用它，然后释放它。

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

int main() {
    int *ptr = (int *)malloc(sizeof(int));
    if (ptr != NULL) {
        *ptr = 10;
        printf("Value: %d\n", *ptr);
        free(ptr);
    }
    return 0;
}

习题十八：指针与指针数组

创建一个指针数组，并初始化。

#include <stdio.h>

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

习题十九：指针与函数指针

使用函数指针调用函数。

#include <stdio.h>

void print_int(int num) {
    printf("Integer: %d\n", num);
}

void print_float(float num) {
    printf("Float: %f\n", num);
}

int main() {
    void (*func_ptr)(int) = print_int;
    func_ptr(10);
    func_ptr = print_float;
    func_ptr(3.14f);
    return 0;
}

习题二十：指针与结构体指针

使用结构体指针访问结构体成员。

#include <stdio.h>

typedef struct {
    int x;
    float y;
} Point;

int main() {
    Point p = {1, 2.5f};
    Point *ptr = &p;
    printf("Point x: %d, y: %f\n", ptr->x, ptr->y);
    return 0;
}

习题二十一：指针与递归

使用指针和递归计算阶乘。

#include <stdio.h>

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

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

习题二十二：指针与动态内存分配

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

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

int main() {
    int *ptr = (int *)malloc(sizeof(int));
    if (ptr != NULL) {
        *ptr = 10;
        printf("Value: %d\n", *ptr);
        free(ptr);
    }
    return 0;
}

习题二十三：指针与数组

使用指针遍历数组。

#include <stdio.h>

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

习题二十四：指针与指针算术

使用指针算术移动指针。

#include <stdio.h>

int main() {
    int a = 10, b = 20;
    int *p = &a;
    p = &b; // Move pointer to b
    printf("Value of b: %d\n", *p);
    return 0;
}

习题二十五：指针与函数参数

使用指针作为函数参数修改变量。

#include <stdio.h>

void modify_value(int *ptr) {
    *ptr = 20;
}

int main() {
    int x = 10;
    modify_value(&x);
    printf("x after modify_value: %d\n", x); // x becomes 20
    return 0;
}

习题二十六：指针与指针数组

使用指针数组访问多个变量。

#include <stdio.h>

int main() {
    int a = 10, b = 20, c = 30;
    int *ptr_array[3] = {&a, &b, &c};
    printf("Values: %d, %d, %d\n", *ptr_array[0], *ptr_array[1], *ptr_array[2]);
    return 0;
}

习题二十七：指针与结构体数组

使用结构体数组访问结构体成员。

#include <stdio.h>

typedef struct {
    int x;
    float y;
} Point;

int main() {
    Point points[3] = {{1, 2.5f}, {3, 4.5f}, {5, 6.5f}};
    for (int i = 0; i < 3; i++) {
        printf("Point %d: x = %d, y = %f\n", i, points[i].x, points[i].y);
    }
    return 0;
}

习题二十八：指针与函数指针数组

使用函数指针数组调用不同的函数。

#include <stdio.h>

void print_int(int num) {
    printf("Integer: %d\n", num);
}

void print_float(float num) {
    printf("Float: %f\n", num);
}

int main() {
    void (*func_ptr_array[2])(int) = {print_int, print_float};
    func_ptr_array[0](10);
    func_ptr_array[1](3.14f);
    return 0;
}

习题二十九：指针与多级指针

使用多级指针访问嵌套结构体成员。

#include <stdio.h>

typedef struct {
    int x;
    struct {
        int y;
        int z;
    } nested;
} ComplexStruct;

int main() {
    ComplexStruct cs = {1, {2, 3}};
    int *ptr = &cs.nested.y;
    printf("Nested y: %d\n", *ptr);
    return 0;
}

习题三十：指针与函数指针类型转换

将函数指针转换为不同的函数指针类型。

#include <stdio.h>

void print_int(int num) {
    printf("Integer: %d\n", num);
}

void print_float(float num) {
    printf("Float: %f\n", num);
}

int main() {
    void (*func_ptr_int)(int) = print_int;
    void (*func_ptr_float)(float) = print_float;
    func_ptr_int = (void (*)(float))func_ptr_float; // Type casting
    func_ptr_int(3.14f);
    return 0;
}

习题三十一：指针与内存对齐

分析结构体成员的内存对齐问题。

#include <stdio.h>
#include <stdint.h>

typedef struct {
    int32_t a;
    int8_t b;
    int16_t c;
} AlignStruct;

int main() {
    printf("Size of AlignStruct: %zu\n", sizeof(AlignStruct));
    return 0;
}

习题三十二：指针与位字段

使用位字段定义一个结构体，并通过指针操作位字段。

#include <stdio.h>

typedef struct {
    uint8_t a : 3;
    uint8_t b : 5;
    uint8_t c : 5;
} BitFieldStruct;

int main() {
    BitFieldStruct bfs = {0, 0, 0};
    bfs.a = 7; // Set bits in a
    printf("Bits in a: %d\n", bfs.a);
    return 0;
}

习题三十三：指针与函数参数传递

比较通过值传递和指针传递参数对函数行为的影响。

#include <stdio.h>

void modify_value(int value) {
    value = 20;
}

void modify_pointer(int *ptr) {
    *ptr = 20;
}

int main() {
    int x = 10;
    modify_value(x);
    printf("x after modify_value: %d\n", x); // x remains 10

    modify_pointer(&x);
    printf("x after modify_pointer: %d\n", x); // x becomes 20
    return 0;
}

习题三十四：指针与动态内存分配与释放

动态分配内存，使用它，然后释放它。

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

int main() {
    int *ptr = (int *)malloc(sizeof(int));
    if (ptr != NULL) {
        *ptr = 10;
        printf("Value: %d\n", *ptr);
        free(ptr);
    }
    return 0;
}

习题三十五：指针与指针数组

创建一个指针数组，并初始化。

#include <stdio.h>

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

习题三十六：指针与函数指针

使用函数指针调用函数。

”`c #include

void print_int(int num) {

printf("Integer: %d\n", num);

}

void print

引言

习题一：指针的基本概念

习题二：指针与数组

习题三：指针算术

习题四：指针与函数

习题五：指针与字符串

习题六：指针与结构体

习题七：指针与动态内存分配

习题八：指针与函数指针

习题九：指针与递归

习题十：指针与结构体指针数组

习题十一：指针与函数指针数组

习题十二：指针与多级指针

习题十三：指针与函数指针类型转换

习题十四：指针与内存对齐

习题十五：指针与位字段

习题十六：指针与函数参数传递

习题十七：指针与动态内存分配与释放

习题十八：指针与指针数组

习题十九：指针与函数指针

习题二十：指针与结构体指针

习题二十一：指针与递归

习题二十二：指针与动态内存分配

习题二十三：指针与数组

习题二十四：指针与指针算术

习题二十五：指针与函数参数

习题二十六：指针与指针数组

习题二十七：指针与结构体数组

习题二十八：指针与函数指针数组

习题二十九：指针与多级指针

习题三十：指针与函数指针类型转换

习题三十一：指针与内存对齐

习题三十二：指针与位字段

习题三十三：指针与函数参数传递

习题三十四：指针与动态内存分配与释放

习题三十五：指针与指针数组

习题三十六：指针与函数指针

相关阅读

揭秘围布局习题：破解空间布局难题，轻松提升家居美学

揭秘同济高数下册习题：常见错误解析与应对策略

破解同济高数难题，课后习题解析秘籍大公开

揭秘古代汉语课后习题，轻松掌握古文精髓

揭秘古代汉语课后习题，轻松掌握答案技巧

掌握C语言精髓：何钦铭课后习题全攻略揭秘

C语言课后习题解析：吴乃陵版答疑解惑

谭浩强C语言面向对象习题解析：实战解答与技巧揭秘

揭秘C++面向对象编程第四版课后习题通关秘籍

解码发育生物学：揭秘生命成长的百题挑战