指针练习

17 . 指针练习题

1. 交换两个整数的值

题目描述： 编写一个 C 程序，定义一个函数swap，使用指针参数交换两个整数的值。在main函数中调用该函数并输出交换后的结果。

解题思路： 为了交换两个整数的值，可以通过指针传递它们的地址给函数swap。在函数内部，通过解引用指针来交换两个变量的值。这样可以直接修改main函数中变量的值。

程序流程如下：

1. 定义函数swap，接受两个整数指针作为参数。
2. 在swap函数中，使用临时变量交换两个指针指向的值。
3. 在main函数中，声明两个整数变量并初始化。
4. 打印交换前的值。
5. 调用swap函数，传递变量的地址。
6. 打印交换后的值。

详细代码：

#include <stdio.h>

// 定义函数swap，交换两个整数的值
void swap(int *a, int *b) {
    int temp = *a; // 使用临时变量存储*a的值
    *a = *b;       // 将*b的值赋给*a
    *b = temp;     // 将临时变量的值赋给*b
}

int main() {
    int num1, num2;

    // 提示用户输入两个整数
    printf("请输入第一个整数: ");
    scanf("%d", &num1);
    printf("请输入第二个整数: ");
    scanf("%d", &num2);

    // 打印交换前的值
    printf("交换前: num1 = %d, num2 = %d\n", num1, num2);

    // 调用swap函数交换num1和num2的值
    swap(&num1, &num2);

    // 打印交换后的值
    printf("交换后: num1 = %d, num2 = %d\n", num1, num2);

    return 0;
}

代码注释：

• void swap(int *a, int *b)：定义一个名为swap的函数，接受两个整数指针作为参数。

• int temp = *a;：通过解引用指针a，将其指向的值存储在临时变量temp中。

• *a = *b;：将指针b指向的值赋给指针a指向的位置，实现部分交换。

• *b = temp;：将临时变量的值赋给指针b指向的位置，完成交换。

• 在

  main
  

  函数中：

  • 使用&num1和&num2将变量的地址传递给swap函数。
  • 交换前后打印变量的值，验证交换是否成功。

2. 计算数组元素的平均值

题目描述： 编写一个 C 程序，定义一个函数calculateAverage，接受一个整数数组和其大小，返回数组元素的平均值。在main函数中调用该函数并输出结果。

解题思路： 函数calculateAverage通过遍历数组，累加所有元素的值，然后除以数组的大小，计算出平均值。使用指针可以更高效地访问数组元素。

程序流程如下：

1. 定义函数calculateAverage，接受一个整数数组和其大小作为参数。
2. 在函数中，使用指针遍历数组，累加元素的值。
3. 计算并返回平均值。
4. 在main函数中，声明一个整数数组并初始化。
5. 调用calculateAverage函数，传递数组和大小。
6. 输出平均值。

详细代码：

#include <stdio.h>

// 定义函数calculateAverage，返回数组元素的平均值
double calculateAverage(int *arr, int size) {
    int sum = 0;
    for(int i = 0; i < size; i++) {
        sum += *(arr + i); // 使用指针访问数组元素
    }
    return (double)sum / size; // 计算平均值
}

int main() {
    int numbers[5];
    int size = 5;
    double average;

    // 提示用户输入5个整数
    printf("请输入5个整数:\n");
    for(int i = 0; i < size; i++) {
        scanf("%d", &numbers[i]);
    }

    // 调用calculateAverage函数计算平均值
    average = calculateAverage(numbers, size);

    // 输出平均值
    printf("数组元素的平均值是 %.2lf。\n", average);

    return 0;
}

代码注释：

• double calculateAverage(int *arr, int size)：定义一个函数，接受一个整数数组的指针和数组的大小，返回平均值。

• sum += *(arr + i);：通过指针运算访问数组的第i个元素，并累加到sum中。

• (double)sum / size：将sum转换为double类型后，除以size，得到平均值。

• 在

  main
  

  函数中：

  • 声明并初始化一个大小为 5 的整数数组numbers。
  • 使用for循环读取用户输入的 5 个整数。
  • 调用calculateAverage函数，传递数组名（数组名作为指针）和数组大小。
  • 输出计算得到的平均值。

3. 动态内存分配与释放

题目描述： 编写一个 C 程序，使用指针动态分配内存来存储一个整数数组。提示用户输入数组的大小和元素，计算数组元素的总和，最后释放分配的内存。

解题思路： 使用malloc函数动态分配所需大小的内存，并通过指针访问和存储数组元素。完成操作后，使用free函数释放内存，避免内存泄漏。

程序流程如下：

1. 声明一个指向整数的指针。
2. 提示用户输入数组的大小。
3. 使用malloc分配内存。
4. 检查内存是否分配成功。
5. 提示用户输入数组元素，并通过指针存储。
6. 遍历数组，计算总和。
7. 输出总和。
8. 使用free释放分配的内存。

详细代码：

#include <stdio.h>
#include <stdlib.h> // 包含malloc和free函数

int main() {
    int *arr;
    int n;
    int sum = 0;

    // 提示用户输入数组大小
    printf("请输入数组的大小: ");
    scanf("%d", &n);

    // 动态分配内存
    arr = (int *)malloc(n * sizeof(int));
    if(arr == NULL) { // 检查内存是否分配成功
        printf("内存分配失败。\n");
        return 1; // 非正常退出
    }

    // 提示用户输入数组元素
    printf("请输入 %d 个整数:\n", n);
    for(int i = 0; i < n; i++) {
        scanf("%d", arr + i); // 使用指针访问数组元素
    }

    // 计算总和
    for(int i = 0; i < n; i++) {
        sum += *(arr + i);
    }

    // 输出总和
    printf("数组元素的总和是 %d。\n", sum);

    // 释放内存
    free(arr);
    printf("内存已释放。\n");

    return 0;
}

代码注释：

• #include <stdlib.h>：包含malloc和free函数的库。
• int *arr;：声明一个指向整数的指针，用于动态分配内存。
• arr = (int *)malloc(n * sizeof(int));：动态分配n个整数所需的内存，并将地址赋给arr。
• if(arr == NULL)：检查内存分配是否成功，若失败则输出错误信息并退出。
• scanf("%d", arr + i);：通过指针运算访问数组元素，存储用户输入的值。
• sum += *(arr + i);：通过指针运算访问数组元素并累加到sum中。
• free(arr);：释放动态分配的内存，避免内存泄漏。

4. 字符串处理与指针

题目描述： 编写一个 C 程序，定义一个函数toUpperCase，接受一个字符串指针，将字符串中的所有小写字母转换为大写字母。在main函数中调用该函数并输出结果。

解题思路： 函数toUpperCase通过遍历字符串，检查每个字符是否为小写字母。如果是，则将其转换为大写字母。使用指针可以直接修改字符串中的字符。

程序流程如下：

1. 定义函数toUpperCase，接受一个字符指针作为参数。
2. 在函数中，遍历字符串，使用 ASCII 值将小写字母转换为大写字母。
3. 在main函数中，声明一个字符数组并初始化。
4. 打印转换前的字符串。
5. 调用toUpperCase函数，传递字符串的指针。
6. 打印转换后的字符串。

详细代码：

#include <stdio.h>
#include <ctype.h> // 包含toupper函数

// 定义函数toUpperCase，转换字符串中的小写字母为大写字母
void toUpperCase(char *str) {
    while(*str != '\0') { // 遍历字符串直到结束符
        if(islower(*str)) { // 检查是否为小写字母
            *str = toupper(*str); // 转换为大写字母
        }
        str++; // 移动指针到下一个字符
    }
}

int main() {
    char str[100];

    // 提示用户输入一个字符串
    printf("请输入一个字符串: ");
    fgets(str, sizeof(str), stdin);

    // 去除换行符
    for(int i = 0; str[i] != '\0'; i++) {
        if(str[i] == '\n') {
            str[i] = '\0';
            break;
        }
    }

    // 打印转换前的字符串
    printf("转换前的字符串: %s\n", str);

    // 调用toUpperCase函数转换字符串
    toUpperCase(str);

    // 打印转换后的字符串
    printf("转换后的字符串: %s\n", str);

    return 0;
}

代码注释：

• #include <ctype.h>：包含字符处理函数，如islower和toupper。

• void toUpperCase(char *str)：定义一个函数，接受一个字符指针，遍历并转换字符串中的小写字母。

• if(islower(*str))：检查当前字符是否为小写字母。

• *str = toupper(*str);：将小写字母转换为大写字母。

• 在

  main
  

  函数中：

  • 使用fgets读取用户输入的字符串，包括空格。
  • 遍历字符串，遇到\n则替换为\0，去除换行符。
  • 调用toUpperCase函数，传递字符串的指针。
  • 输出转换前后字符串的内容。

5. 指针与数组的关系

题目描述： 编写一个 C 程序，定义一个整数数组和一个指针指向该数组的第一个元素。使用指针遍历数组并打印所有元素的值。

解题思路： 在 C 中，数组名实际上是指向数组第一个元素的指针。通过指针运算，可以遍历数组中的所有元素。程序流程如下：

1. 声明并初始化一个整数数组。
2. 声明一个指针，并指向数组的第一个元素。
3. 使用指针遍历数组，打印每个元素的值。
4. 通过指针加法或递增指针来访问下一个元素。

详细代码：

#include <stdio.h>

int main() {
    int arr[5] = {10, 20, 30, 40, 50};
    int *ptr = arr; // 指针指向数组的第一个元素

    // 使用指针遍历数组并打印元素
    printf("数组元素为:\n");
    for(int i = 0; i < 5; i++) {
        printf("arr[%d] = %d\n", i, *(ptr + i)); // 使用指针加法访问元素
    }

    return 0;
}

代码注释：

• int *ptr = arr;：声明一个指针ptr，指向数组arr的第一个元素。数组名arr作为指针指向第一个元素。
• *(ptr + i)：通过指针运算访问数组的第i个元素。ptr + i指向数组的第i个元素，*用于解引用获取值。
• 使用for循环遍历数组，并打印每个元素的值。

6. 指向指针的指针

题目描述： 编写一个 C 程序，定义一个整数变量和一个指针指向该变量。然后定义一个指向指针的指针。通过指针的指针修改整数变量的值，并打印修改后的结果。

解题思路： 通过多级指针（指向指针的指针），可以间接地修改变量的值。程序流程如下：

1. 声明一个整数变量并初始化。
2. 声明一个指针，指向该整数变量。
3. 声明一个指向指针的指针，指向上述指针。
4. 使用指针的指针修改整数变量的值。
5. 打印修改后的整数值。

详细代码：

#include <stdio.h>

int main() {
    int num = 100;
    int *ptr = &num;    // 指针指向num
    int **pptr = &ptr;  // 指向指针ptr的指针

    // 打印初始值
    printf("初始值: num = %d\n", num);
    printf("通过ptr访问: *ptr = %d\n", *ptr);
    printf("通过pptr访问: **pptr = %d\n", **pptr);

    // 使用指针的指针修改num的值
    **pptr = 200;

    // 打印修改后的值
    printf("修改后: num = %d\n", num);
    printf("通过ptr访问: *ptr = %d\n", *ptr);
    printf("通过pptr访问: **pptr = %d\n", **pptr);

    return 0;
}

代码注释：

• int *ptr = #：声明一个指针ptr，指向整数变量num。
• int **pptr = &ptr;：声明一个指针的指针pptr，指向指针ptr。
• **pptr = 200;：通过指针的指针修改num的值。*pptr解引用得到ptr，**pptr解引用得到num。
• 打印初始值和修改后的值，验证修改是否成功。

7. 指针与函数的结合

题目描述： 编写一个 C 程序，定义一个函数increment，接受一个整数指针参数，将指针指向的整数值增加 1。在main函数中调用该函数并输出结果。

解题思路： 函数increment通过指针访问并修改传递的整数变量。使用指针参数可以直接在函数内部修改变量的值。

程序流程如下：

1. 定义函数increment，接受一个整数指针作为参数。
2. 在函数中，将指针指向的整数值增加 1。
3. 在main函数中，声明一个整数变量并初始化。
4. 打印变量增加前的值。
5. 调用increment函数，传递变量的地址。
6. 打印变量增加后的值。

详细代码：

#include <stdio.h>

// 定义函数increment，增加指针指向的整数值
void increment(int *num) {
    (*num)++; // 将指针指向的整数值增加1
}

int main() {
    int value = 10;

    // 打印增加前的值
    printf("增加前的值: %d\n", value);

    // 调用increment函数，传递变量的地址
    increment(&value);

    // 打印增加后的值
    printf("增加后的值: %d\n", value);

    return 0;
}

代码注释：

• void increment(int *num)：定义一个函数，接受一个整数指针参数。

• (*num)++;：解引用指针num，将其指向的整数值增加 1。

• 在

  main
  

  函数中：

  • 声明一个整数变量value并初始化为 10。
  • 打印变量增加前的值。
  • 调用increment(&value)，传递变量的地址。
  • 打印变量增加后的值，验证增加是否成功。

8. 指针数组

题目描述： 编写一个 C 程序，定义一个指针数组，用于存储 5 个字符串的地址。初始化指针数组并打印所有字符串。

解题思路： 指针数组是一个数组，其元素是指向特定类型的指针。在本例中，定义一个指针数组，每个元素指向一个字符串常量。通过遍历指针数组，可以访问和打印所有字符串。

程序流程如下：

1. 定义一个指针数组，大小为 5，每个元素是指向字符的指针。
2. 初始化指针数组，存储 5 个字符串的地址。
3. 使用for循环遍历指针数组，打印每个字符串。

详细代码：

#include <stdio.h>

int main() {
    // 定义并初始化指针数组，存储5个字符串的地址
    const char *strArray[5] = {
        "Hello",
        "World",
        "C",
        "Programming",
        "Pointers"
    };

    // 打印所有字符串
    printf("指针数组中的字符串为:\n");
    for(int i = 0; i < 5; i++) {
        printf("strArray[%d] = %s\n", i, strArray[i]);
    }

    return 0;
}

代码注释：

• const char *strArray[5]：声明一个指针数组strArray，每个元素是指向常量字符的指针。
• 初始化指针数组，存储 5 个字符串的地址。
• 使用for循环遍历指针数组，通过指针访问每个字符串并打印。

9. 指针与多维数组

题目描述： 编写一个 C 程序，定义一个 3x3 的二维数组和一个指向该数组的指针。使用指针访问并修改数组中的元素，然后打印修改后的数组。

解题思路： 指向二维数组的指针需要正确地定义和使用。通过指针运算，可以访问和修改二维数组中的元素。程序流程如下：

1. 定义一个 3x3 的二维数组并初始化。
2. 定义一个指向该二维数组的指针。
3. 使用指针访问并修改数组中的特定元素。
4. 打印修改后的数组。

详细代码：

#include <stdio.h>

int main() {
    int arr[3][3] = {
        {1, 2, 3},
        {4, 5, 6},
        {7, 8, 9}
    };
    int (*ptr)[3] = arr; // 指向包含3个整数的数组的指针

    // 修改数组中的元素，例如将arr[1][1]改为50
    *(*(ptr + 1) + 1) = 50;

    // 打印修改后的数组
    printf("修改后的二维数组:\n");
    for(int i = 0; i < 3; i++) { // 遍历行
        for(int j = 0; j < 3; j++) { // 遍历列
            printf("%d ", *(*(ptr + i) + j)); // 使用指针访问元素
        }
        printf("\n"); // 换行
    }

    return 0;
}

代码注释：

• int (*ptr)[3] = arr;：声明一个指针ptr，指向包含 3 个整数的一维数组（即二维数组的行）。
• *(*(ptr + 1) + 1) = 50;：通过指针运算访问并修改二维数组中第二行第二列的元素，将其值改为 50。
• 使用嵌套for循环，通过指针访问和打印修改后的数组元素。

10. 动态二维数组

题目描述： 编写一个 C 程序，使用指针动态分配内存来创建一个二维整数数组。提示用户输入行数和列数，输入数组元素，计算每行的总和，并释放分配的内存。

解题思路： 动态分配二维数组可以通过分配指针数组的内存，再为每个指针分配列的内存。程序流程如下：

1. 提示用户输入行数和列数。
2. 使用malloc动态分配内存为行指针数组。
3. 为每一行分配内存以存储列元素。
4. 提示用户输入二维数组的元素。
5. 计算并打印每行的总和。
6. 释放所有分配的内存。

详细代码：

#include <stdio.h>
#include <stdlib.h> // 包含malloc和free函数

int main() {
    int rows, cols;
    int **arr;
    int sum;

    // 提示用户输入行数和列数
    printf("请输入二维数组的行数和列数: ");
    scanf("%d %d", &rows, &cols);

    // 动态分配内存为行指针数组
    arr = (int **)malloc(rows * sizeof(int *));
    if(arr == NULL) {
        printf("内存分配失败。\n");
        return 1;
    }

    // 为每一行分配内存
    for(int i = 0; i < rows; i++) {
        arr[i] = (int *)malloc(cols * sizeof(int));
        if(arr[i] == NULL) {
            printf("内存分配失败。\n");
            // 释放之前已分配的内存
            for(int j = 0; j < i; j++) {
                free(arr[j]);
            }
            free(arr);
            return 1;
        }
    }

    // 提示用户输入二维数组的元素
    printf("请输入二维数组的元素:\n");
    for(int i = 0; i < rows; i++) {
        printf("请输入第 %d 行的 %d 个元素:\n", i + 1, cols);
        for(int j = 0; j < cols; j++) {
            scanf("%d", &arr[i][j]);
        }
    }

    // 计算并打印每行的总和
    for(int i = 0; i < rows; i++) {
        sum = 0;
        for(int j = 0; j < cols; j++) {
            sum += arr[i][j];
        }
        printf("第 %d 行的总和是 %d。\n", i + 1, sum);
    }

    // 释放内存
    for(int i = 0; i < rows; i++) {
        free(arr[i]); // 释放每一行的内存
    }
    free(arr); // 释放行指针数组的内存
    printf("内存已释放。\n");

    return 0;
}

代码注释：

• int **arr;：声明一个指向指针的指针，用于动态分配二维数组。

• arr = (int **)malloc(rows * sizeof(int *));：为行指针数组分配内存，每个元素是指向整数的指针。

• 内层

  for
  

  循环：

  • arr[i] = (int *)malloc(cols * sizeof(int));：为每一行分配内存，以存储cols个整数。
  • 检查每次内存分配是否成功，若失败，则释放之前分配的内存并退出。

• 输入二维数组的元素：

  • 使用嵌套for循环读取用户输入的二维数组元素。

• 计算每行的总和：

  • 使用嵌套for循环遍历每一行的元素，累加求和。

• 释放内存：

  • 首先释放每一行分配的内存。
  • 然后释放行指针数组的内存，确保所有动态分配的内存都被正确释放，避免内存泄漏。

11. 指针作为函数返回值

题目描述： 编写一个 C 程序，定义一个函数createArray，接受一个整数参数n，动态分配一个大小为n的整数数组，初始化数组元素为 0，并返回指向该数组的指针。在main函数中调用该函数，输入数组大小，打印数组元素，并释放分配的内存。

解题思路： 函数createArray通过malloc动态分配内存，初始化数组元素为 0，并返回指向数组的指针。在main函数中，调用该函数获取数组指针，进行操作后释放内存。

程序流程如下：

1. 定义函数createArray，接受整数n，返回指向整数的指针。
2. 在函数中，使用malloc分配内存，并初始化元素为 0。
3. 返回指针。
4. 在main函数中，提示用户输入数组大小。
5. 调用createArray函数，获取数组指针。
6. 打印数组元素，验证初始化。
7. 使用free释放内存。

详细代码：

#include <stdio.h>
#include <stdlib.h> // 包含malloc和free函数

// 定义函数createArray，动态分配并初始化数组
int* createArray(int n) {
    int *arr = (int *)malloc(n * sizeof(int));
    if(arr == NULL) {
        printf("内存分配失败。\n");
        return NULL;
    }

    // 初始化数组元素为0
    for(int i = 0; i < n; i++) {
        arr[i] = 0;
    }

    return arr; // 返回指向数组的指针
}

int main() {
    int size;
    int *array;

    // 提示用户输入数组大小
    printf("请输入数组的大小: ");
    scanf("%d", &size);

    // 调用createArray函数创建数组
    array = createArray(size);
    if(array == NULL) {
        return 1; // 内存分配失败，退出程序
    }

    // 打印数组元素
    printf("初始化后的数组元素为:\n");
    for(int i = 0; i < size; i++) {
        printf("array[%d] = %d\n", i, array[i]);
    }

    // 释放内存
    free(array);
    printf("内存已释放。\n");

    return 0;
}

代码注释：

• int* createArray(int n)：定义一个函数，接受整数n，返回指向整数的指针。

• int *arr = (int *)malloc(n * sizeof(int));：动态分配内存，存储n个整数。

• if(arr == NULL)：检查内存分配是否成功，若失败则输出错误信息并返回NULL。

• for(int i = 0; i < n; i++)：初始化数组元素为 0。

• return arr;：返回指向数组的指针。

• 在

  main
  

  函数中：

  • 使用scanf读取用户输入的数组大小。
  • 调用createArray(size)，获取数组指针array。
  • 检查array是否为NULL，若是则退出程序。
  • 使用for循环打印数组元素，验证初始化是否成功。
  • 使用free(array);释放动态分配的内存。

12. 指针与字符串的逆序

题目描述： 编写一个 C 程序，定义一个函数reverseString，接受一个字符串指针，将字符串逆序。使用指针操作进行逆序。在main函数中调用该函数并输出结果。

解题思路： 函数reverseString通过指针找到字符串的末尾，然后使用双指针法交换前后字符，逐步向中间移动，实现字符串的逆序。

程序流程如下：

1. 定义函数reverseString，接受一个字符指针作为参数。
2. 在函数中，找到字符串的长度。
3. 使用两个指针，一个指向字符串的开始，一个指向字符串的末尾。
4. 交换两个指针指向的字符，逐步向中间移动。
5. 在main函数中，声明一个字符串并初始化。
6. 打印原始字符串。
7. 调用reverseString函数，传递字符串的指针。
8. 打印逆序后的字符串。

详细代码：

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

// 定义函数reverseString，逆序字符串
void reverseString(char *str) {
    char *start = str; // 指向字符串的开始
    char *end = str + strlen(str) - 1; // 指向字符串的末尾（不包括结束符）

    while(start < end) {
        // 交换start和end指向的字符
        char temp = *start;
        *start = *end;
        *end = temp;

        // 移动指针
        start++;
        end--;
    }
}

int main() {
    char str[100];

    // 提示用户输入一个字符串
    printf("请输入一个字符串: ");
    fgets(str, sizeof(str), stdin);

    // 去除换行符
    for(int i = 0; str[i] != '\0'; i++) {
        if(str[i] == '\n') {
            str[i] = '\0';
            break;
        }
    }

    // 打印原始字符串
    printf("原始字符串: %s\n", str);

    // 调用reverseString函数逆序字符串
    reverseString(str);

    // 打印逆序后的字符串
    printf("逆序后的字符串: %s\n", str);

    return 0;
}

代码注释：

• void reverseString(char *str)：定义一个函数，接受一个字符指针，逆序字符串。

• char *start = str;：指针start指向字符串的开始。

• char *end = str + strlen(str) - 1;：指针end指向字符串的末尾字符（不包括结束符\0）。

• while(start < end)：循环条件，确保指针start在指针end之前。

• 交换*start和*end指向的字符，实现字符交换。

• start++和end--：移动指针，逐步向中间靠拢。

• 在

  main
  

  函数中：

  • 使用fgets读取用户输入的字符串，包括空格。
  • 遍历字符串，遇到\n则替换为\0，去除换行符。
  • 调用reverseString函数，传递字符串的指针。
  • 输出逆序后的字符串。

13. 指针与结构体

题目描述： 编写一个 C 程序，定义一个结构体Person，包含姓名和年龄两个成员。定义一个函数printPerson，接受一个指向Person结构体的指针，并打印其信息。在main函数中创建一个Person实例，初始化其成员，调用printPerson函数。

解题思路： 使用结构体来存储相关的数据，通过指针传递结构体实例给函数，函数通过指针访问和打印结构体成员。

程序流程如下：

1. 定义结构体Person，包含name和age两个成员。
2. 定义函数printPerson，接受一个指向Person的指针，打印结构体成员。
3. 在main函数中，声明一个Person变量并初始化。
4. 调用printPerson函数，传递结构体变量的指针。
5. 打印结构体信息。

详细代码：

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

// 定义结构体Person
typedef struct {
    char name[50];
    int age;
} Person;

// 定义函数printPerson，打印Person的信息
void printPerson(Person *p) {
    printf("姓名: %s\n", p->name);
    printf("年龄: %d\n", p->age);
}

int main() {
    Person person;

    // 提示用户输入姓名和年龄
    printf("请输入姓名: ");
    fgets(person.name, sizeof(person.name), stdin);
    // 去除换行符
    for(int i = 0; person.name[i] != '\0'; i++) {
        if(person.name[i] == '\n') {
            person.name[i] = '\0';
            break;
        }
    }

    printf("请输入年龄: ");
    scanf("%d", &person.age);

    // 调用printPerson函数打印信息
    printf("\n--- 人员信息 ---\n");
    printPerson(&person);

    return 0;
}

代码注释：

• typedef struct { ... } Person;：定义一个结构体Person，包含name和age。

• void printPerson(Person *p)：定义一个函数，接受一个指向Person结构体的指针。

• p->name和p->age：通过指针访问结构体的成员。

• 在

  main
  

  函数中：

  • 声明一个Person变量person。
  • 使用fgets读取用户输入的姓名，包括空格。
  • 遍历姓名字符串，遇到\n则替换为\0，去除换行符。
  • 使用scanf读取用户输入的年龄。
  • 调用printPerson(&person)，传递结构体变量的地址。
  • printPerson函数打印person的姓名和年龄。

14. 指针与字符串复制

题目描述： 编写一个 C 程序，定义一个函数copyString，接受两个字符串指针（源字符串和目标字符串），将源字符串复制到目标字符串。不要使用标准库函数。 在main函数中调用该函数并输出结果。

解题思路： 函数copyString通过指针遍历源字符串，将每个字符复制到目标字符串，直到遇到字符串结束符\0。确保目标字符串也以\0结束。

程序流程如下：

1. 定义函数copyString，接受两个字符指针（源和目标）。
2. 在函数中，使用while循环遍历源字符串。
3. 将源字符串的每个字符复制到目标字符串。
4. 添加字符串结束符\0。
5. 在main函数中，声明两个字符串数组。
6. 提示用户输入源字符串。
7. 调用copyString函数，传递源和目标字符串的指针。
8. 打印目标字符串，验证复制是否成功。

详细代码：

#include <stdio.h>

// 定义函数copyString，复制源字符串到目标字符串
void copyString(char *source, char *destination) {
    while(*source != '\0') { // 遍历源字符串
        *destination = *source; // 复制当前字符
        source++; // 移动源指针
        destination++; // 移动目标指针
    }
    *destination = '\0'; // 添加字符串结束符
}

int main() {
    char source[100];
    char destination[100];

    // 提示用户输入源字符串
    printf("请输入源字符串: ");
    fgets(source, sizeof(source), stdin);

    // 去除源字符串中的换行符
    for(int i = 0; source[i] != '\0'; i++) {
        if(source[i] == '\n') {
            source[i] = '\0';
            break;
        }
    }

    // 调用copyString函数复制字符串
    copyString(source, destination);

    // 输出复制后的字符串
    printf("复制后的字符串: %s\n", destination);

    return 0;
}