• c语言指针

    指针

    在C语言中，变量名不是地址。变量名是用来标识内存地址的符号，它表示变量在计算机内存中的位置。当定义一个变量时，系统会为该变量分配一个内存地址，并且可以使用变量名来访问该变量的值。

    在C语言中，指针是一种特殊的变量，它存储的是其他变量的内存地址，而不是值本身。通过指针，我们可以间接地访问和修改其指向的内存区域的值。

    指针的声明和定义如下：

    数据类型 *指针变量名;

    其中，数据类型可以是任何有效的C语言数据类型，如int、char、float等。指针变量名是你为指针变量选择的名称。

    下面是一个完整的例子，演示了如何声明、定义和使用指针变量：

    ​

    1. #include   
    2.   
    3. int main() {  
    4.     int num = 10;  
    5.     int *ptr; // 声明指针变量ptr  
    6.     ptr = # // 将num的地址赋值给ptr  
    7.   
    8.     printf("num的值为：%d\n", num);  
    9.     printf("num的地址为：%p\n", &num);  
    10.     printf("ptr指向的值为：%d\n", *ptr);  
    11.     printf("ptr的地址为：%p\n", ptr);  
    12.   
    13.     return 0;  
    14. }

    在上面的例子中，我们声明了一个整型变量num并初始化为10。然后声明了一个指向整型的指针变量ptr。通过将&num赋值给ptr，我们将num的地址存储在了ptr中。使用*ptr可以访问ptr所指向的内存区域的值，即num的值。通过&num可以得到num的地址。程序输出了num的值、num的地址、ptr指向的值以及ptr的地址。

    数据交互：

    可以使用指针来交换两个变量的值，这是一个非常常见的使用指针的例子。以下是一个使用 C 语言实现的示例：

    首先，定义一个交换函数，它接收两个整数的指针：

    ​
#include   
  
void swap(int *a, int *b) {  
    int temp = *a;  
    *a = *b;  
    *b = temp;  
}

    然后，你可以在主函数中这样使用这个函数：

    ​
​
int main() {  
    int x = 5;  
    int y = 10;  
    printf("Before swap: x = %d, y = %d\n", x, y);  
    swap(&x, &y);  
    printf("After swap: x = %d, y = %d\n", x, y);  
    return 0;  
}

    在这个例子中，swap函数通过接收两个指针来交换两个整数的值。当我们调用swap(&x, &y)时，我们传递的是x和y的地址，所以函数能够直接影响到这两个变量的值。

    ps:

    在C语言中，函数的参数传递是值传递。这意味着当你传递一个变量到函数中时，函数会创建一个新的副本，而不是直接引用原始变量。因此，在函数内部对参数的任何修改都不会影响原始变量的值。

    下面是一个简单的示例来说明这个概念：

    ​

    1. #include   
    2.   
    3. void addOne(int num) {  
    4.     num = num + 1;  
    5.     printf("num inside the function: %d\n", num);  
    6. }  
    7.   
    8. int main() {  
    9.     int num = 0;  
    10.     addOne(num);  
    11.     printf("num in main: %d\n", num);  
    12.     return 0;  
    13. }

    在这个例子中，addOne函数接收一个整数参数num，然后对它加一。然而，这种修改不会影响到main函数中的num变量。输出将是：

    makefile复制代码
​
num inside the function: 1  
num in main: 0

    这表明尽管在函数内部num的值被改变了，但这种改变并没有影响到函数外部的原始变量。这就是因为在C语言中，函数参数是通过值传递的。

    如果你希望在函数中修改一个变量的值，并影响到原始变量，你需要使用指针。通过指针，你可以直接引用和修改内存中的原始值，而不是传递一个副本。

    数组与指针

    在C语言中，数组和指针之间有一个非常紧密的关系。数组的名称可以被看作是一个指向数组第一个元素的指针。同样，一个指向某个特定类型的指针也可以被看作是一个指向该类型的数组。这种关系可以在下面的示例代码中看到：

    ​

    1. #include   
    2.   
    3. int main() {  
    4.     // 定义一个包含5个整数的数组  
    5.     int array[5] = {1, 2, 3, 4, 5};  
    6.   
    7.     // 定义一个指向整数的指针  
    8.     int *ptr;  
    9.   
    10.     // 将ptr指向array的第一个元素  
    11.     ptr = array;  
    12.   
    13.     // 使用指针访问数组元素  
    14.     for(int i = 0; i < 5; i++) {  
    15.         printf("array[%d] = %d\n", i, *(ptr + i));  
    16.     }  
    17.   
    18.     // 修改数组中的元素值通过指针  
    19.     *(ptr + 2) = 20;  
    20.   
    21.     // 打印修改后的数组  
    22.     printf("Modified array: ");  
    23.     for(int i = 0; i < 5; i++) {  
    24.         printf("%d ", array[i]);  
    25.     }  
    26.     printf("\n");  
    27.   
    28.     return 0;  
    29. }

    在这个例子中，我们首先定义了一个包含5个整数的数组array，然后定义了一个指向整数的指针ptr。我们将ptr指向array的第一个元素，然后使用一个循环通过指针访问数组的每个元素。我们也可以使用指针修改数组中的元素值，如示例中我们将第三个元素值修改为20。

    二维数组的指针：

    1. include 
    2. int main(void)
    3. ​
    4. {
    5. ​
    6. int zippo[4][2] = { {2,4}, {6,8}, {1,3}, {5, 7} };
    7. int (*pz)[2];
    8. pz = zippo;
    9. ​
    10. printf("   pz = %p,    pz + 1 = %p\n",
    11.        pz,         pz + 1);
    12. printf("pz[0] = %p, pz[0] + 1 = %p\n",
    13.        pz[0],      pz[0] + 1);
    14. printf("  *pz = %p,   *pz + 1 = %p\n",
    15.        *pz,        *pz + 1);
    16. printf("pz[0][0] = %d\n", pz[0][0]);
    17. printf("  *pz[0] = %d\n", *pz[0]);
    18. printf("    **pz = %d\n", **pz);
    19. printf("      pz[2][1] = %d\n", pz[2][1]);
    20. printf("*(*(pz+2) + 1) = %d\n", *(*(pz+2) + 1));
    21. ​
    22. return 0;
    23. }
    24. /* zippo1.c -- zippo info */
    25.  
    26.  
    27.  
    28. ​
    29.  
    30. include 
    31. int main(void)
    32. {
    33. int zippo[4][2] = { {2,4}, {6,8}, {1,3}, {5, 7} };
    34. ​
    35. printf("   zippo = %p,    zippo + 1 = %p\n",
    36.        zippo,         zippo + 1);
    37. printf("zippo[0] = %p, zippo[0] + 1 = %p\n",
    38.        zippo[0],      zippo[0] + 1);
    39. printf("  *zippo = %p,   *zippo + 1 = %p\n",
    40.        *zippo,        *zippo + 1);
    41. printf("zippo[0][0] = %d\n", zippo[0][0]);
    42. printf("  *zippo[0] = %d\n", *zippo[0]);
    43. printf("    **zippo = %d\n", **zippo);
    44. printf("      zippo[2][1] = %d\n", zippo[2][1]);
    45. printf("*(*(zippo+2) + 1) = %d\n", *(*(zippo+2) + 1));
    46. ​
    47. return 0;
    48. }

    函数与指针

    函数指针是指向函数的指针变量。它可以用来存储函数的地址，并在需要时调用该函数。下面是一个简单的例子，演示了如何定义和使用函数指针。

    1. #include   
    2.   
    3. // 定义一个函数，用于计算两个整数的和  
    4. int add(int x, int y) {  
    5.     return x + y;  
    6. }  
    7.   
    8. int main() {  
    9.     // 定义一个函数指针，指向add函数  
    10.     int (*fp)(int, int) = add;  
    11.   
    12.     // 定义一个整数数组  
    13.     int arr[] = {1, 2, 3, 4, 5};  
    14.   
    15.     // 使用函数指针调用add函数，计算数组元素的和  
    16.     int sum = 0;  
    17.     for (int i = 0; i < 5; i++) {  
    18.         sum = fp(sum, arr[i]);  
    19.     }  
    20.   
    21.     // 输出计算结果  
    22.     printf("Sum of array elements: %d\n", sum);  
    23.   
    24.     return 0;  
    25. }

    在这个例子中，我们定义了一个函数add，用于计算两个整数的和。然后，我们定义了一个函数指针fp，指向add函数。在main函数中，我们使用fp来调用add函数，计算一个整数数组的元素之和，并输出结果。

    在C语言中，函数指针是指向函数的指针变量。它通常用于回调函数、函数参数传递和函数表等场景。分别给出这三个场景下应用的例子

    当然，以下是函数指针在C语言中的三种常见应用场景的例子：

    1. 回调函数（Callback Functions）

    在C语言中，函数指针最常见的用途是实现回调函数。以下是一个简单的例子：

    1. #include   
    2.   
    3. // 定义一个函数指针类型  
    4. typedef void (*callback_t)(int);  
    5.   
    6. // 定义一个函数，这个函数接受一个整数和一个回调函数  
    7. void demo_function(int x, callback_t callback) {  
    8.     printf("The value of x is: %d\n", x);  
    9.     // 调用回调函数  
    10.     callback(x);  
    11. }  
    12.   
    13. // 定义一个回调函数，用于输出一个整数的平方  
    14. void square(int x) {  
    15.     printf("The square of %d is: %d\n", x, x * x);  
    16. }  
    17.   
    18. int main() {  
    19.     // 调用demo_function函数，并传入回调函数square  
    20.     demo_function(5, square);  
    21.     return 0;  
    22. }

    1. 函数参数传递（Function Parameters Passing）

    函数指针也可以作为参数传递给其他函数，以实现更灵活的功能。以下是一个例子：

    1. #include   
    2.   
    3. // 定义一个函数，这个函数接受一个整数和一个函数指针  
    4. void apply_func(int x, void (*func)(int)) {  
    5.     func(x);  
    6. }  
    7.   
    8. // 定义一个函数，用于输出一个整数的平方  
    9. void square(int x) {  
    10.     printf("The square of %d is: %d\n", x, x * x);  
    11. }  
    12.   
    13. int main() {  
    14.     // 调用apply_func函数，并传入函数square作为参数  
    15.     apply_func(5, square);  
    16.     return 0;  
    17. }

    1. 函数表（Function Tables）

    函数指针还可以用于实现函数表，以便根据运行时的决策来调用不同的函数。以下是一个例子：

    1. #include   
    2.   
    3. // 定义一个函数指针类型，用于指向处理函数的指针数组的函数指针类型  
    4. typedef void (*operation_t)(int);  
    5.   
    6. // 定义几个处理函数  
    7. void print_square(int x) { printf("%d\n", x * x); }  
    8. void print_cube(int x) { printf("%d\n", x * x * x); }  
    9. void print_quartic(int x) { printf("%d\n", x * x * x * x); }  
    10.   
    11. // 定义一个包含这三个函数的函数指针数组（即函数表）  
    12. operation_t operations[] = { print_square, print_cube, print_quartic };  
    13.   
    14. int main() {  
    15.     // 通过函数表调用不同的函数  
    16.     for (int i = 0; i < 3; i++) {  
    17.         operations[i](i + 1);  // 分别计算并打印1的平方、立方和四次方，2的平方、立方和四次方，以及3的平方、立方和四次方。  
    18.     }  
    19.     return 0;  
    20. }

    在C语言中，函数的可变参数（Variable Arguments）是一种特殊的函数参数类型，它允许函数接受可变数量的参数。这种参数类型被表示为...（三个点），通常作为函数参数列表的最后一个参数。

    可变参数的应用场景是在函数需要处理可变数量或类型的参数时，例如函数需要接受任意数量的整数、字符串或其他数据类型，或者需要接受不同数量的参数进行不同的操作。

    下面是一个简单的示例，演示了如何使用可变参数实现一个函数，该函数接受任意数量的整数并计算它们的和：

    1. #include   
    2. #include   
    3.   
    4. int sum(int count, ...) {  
    5.     va_list args;  // 定义一个va_list类型的变量，用于存储可变参数的列表  
    6.     int sum = 0;   // 初始化一个sum变量用于计算总和  
    7.   
    8.     va_start(args, count);  // 初始化args变量，将其指向第一个可变参数  
    9.   
    10.     // 遍历可变参数列表，计算它们的总和  
    11.     for (int i = 0; i < count; i++) {  
    12.         int num = va_arg(args, int);  // 依次获取每个整数参数的值  
    13.         sum += num;  
    14.     }  
    15.   
    16.     va_end(args);  // 清理va_list变量  
    17.   
    18.     return sum;  
    19. }  
    20.   
    21. int main() {  
    22.     int a = 1, b = 2, c = 3;  
    23.     printf("Sum: %d\n", sum(3, a, b, c));  // 输出：Sum: 6  
    24.     return 0;  
    25. }

    在上面的示例中，sum函数接受一个整数count表示可变参数的数量，然后使用一个va_list类型的变量args来存储可变参数的列表。通过调用va_start宏初始化args变量，然后使用va_arg宏依次获取每个整数参数的值，并计算它们的总和。最后，调用va_end宏清理args变量。

    在C语言中，fopen函数用于打开文件，并返回一个文件指针。如果打开文件成功，它会返回一个指向文件的指针，该指针随后可用于进行其他的输入和输出操作。如果打开文件失败，fopen则会返回NULL。

    文件

    fopen函数的原型如下：

    FILE *fopen(const char *path, const char *mode);

    • path：这是一个字符串，表示要打开的文件的路径或文件名。

    • mode

      ：这也是一个字符串，表示打开文件的模式。下面是一些常见的模式：

      • r：以只读方式打开文件。文件必须存在。

      • w：以只写方式打开文件。如果文件存在，内容会被清空。如果文件不存在，会尝试创建一个新文件。

      • a：以追加方式打开文件。如果文件存在，写操作将在文件的末尾进行。如果文件不存在，会尝试创建一个新文件。

      • r+：以读/写方式打开文件。文件必须存在。

      • w+：以读/写方式打开文件。如果文件存在，内容会被清空。如果文件不存在，会尝试创建一个新文件。

      • a+：以读/追加方式打开文件。如果文件存在，写操作将在文件的末尾进行。如果文件不存在，会尝试创建一个新文件。

      ​

      ​

    在C语言中，fread()函数用于从文件中读取数据。它是一个非常强大的工具，因为它可以读取任意类型的数据，无论是字符、整数、浮点数，还是自定义的数据结构。

    fread()

    fread()函数的原型如下：

    size_t fread(void *ptr, size_t size, size_t nmemb, FILE *stream);

    参数说明：

    • ptr：指向用于存储数据的内存块的指针。

    • size：要读取的每个元素的大小，以字节为单位。

    • nmemb：要读取的元素的数量。

    • stream：指向FILE对象的指针，该对象指定了一个输入流。

    fread()函数会从stream指向的文件中读取nmemb个元素，每个元素的大小为size字节，并将这些数据存储在由ptr指向的内存块中。函数返回成功读取的元素数量。如果返回值小于nmemb，则可能表示发生了错误或者到达了文件的末尾。

    例如，以下代码将从文件中读取一个整数数组：

    1. #include   
    2.   
    3. int main() {  
    4.     FILE *file;  
    5.     int numbers[10];  
    6.     size_t i, n;  
    7.   
    8.     file = fopen("numbers.txt", "r");  
    9.     if (file == NULL) {  
    10.         printf("Cannot open file\n");  
    11.         return 1;  
    12.     }  
    13.   
    14.     n = fread(numbers, sizeof(int), 10, file);  
    15.     for (i = 0; i < n; i++) {  
    16.         printf("%d ", numbers[i]);  
    17.     }  
    18.     printf("\n");  
    19.   
    20.     fclose(file);  
    21.     return 0;  
    22. }

    在这个例子中，我们打开名为"numbers.txt"的文件，并使用fread()函数从文件中读取10个整数。然后，我们遍历这些整数并打印出来。注意，我们使用了sizeof(int)作为fread()的第二个参数，这是因为我们要读取的是整数，所以我们需要知道每个整数在内存中占用的字节数。

  • 相关阅读:
    【圣诞文】用python带你体验多重花样圣诞树
    C++语言基础篇
    【JDBC】02-如何获取数据库连接(展示迭代过程)
    chatgpt的命令词
    EditorConfig + ESLint + Prettier 实现代码规范化
    解码Java的垃圾回收：掌握GC机制，提升代码的稳定性与可伸缩性
    求助帖：React Native failed installing Ruby Gems(rn 下载 Runby Gems 失败)
    SpringBoot【SpringBoot介绍、SpringBoot入门、SpringBoot原理分析、SpringBoot原理分析】(一)-全面详解（学习总结---从入门到深化）
    力扣349 - 两个数组的交集【哈希表+数组+双指针】
    【学习笔记42】操作DOM
  • 原文地址：https://blog.csdn.net/wh_xia_jun/article/details/140130456