2天学完C语言-------二 指针（*和&）

提到指针，是大多数人最头疼的地方。今天就来复习一下指针的知识。

1. 指针的概念和操作

     指针是C语言中的一个重要概念，它用于保存和操作内存地址。通过指针，我们可以直接访问和修改内存中的数据。以下是关于指针的一些基本概念和操作：

1. 指针的声明和初始化

   指针变量用于保存内存地址。通过使用`*`运算符来声明指针变量，并使用`&`运算符获取变量的地址进行初始化。

   int *ptr; // 声明名为ptr的整型指针
   int num = 10;
   ptr = # // 将ptr指向num的地址

2. 解引用（Dereferencing）指针

   解引用指针意味着访问指针指向的内存地址上的值。可以使用`*`运算符解引用指针。

 int value = *ptr; // 通过解引用指针获取存储在ptr指向的内存地址上的值

3. 指针的算术运算

   可以对指针进行算术运算，如加法和减法。这个运算会改变指针所指向的地址。

   int arr[] = {1, 2, 3, 4, 5};
   int *ptr = arr; // 将ptr指向数组的第一个元素
   ptr++; // 移动指针到下一个元素的地址
   int value = *ptr; // 获取ptr指向的内存地址上的值（现在为arr[1]）
   ptr--; // 移动指针回到上一个元素的地址

4. 指针作为函数参数

   指针经常用作函数的参数，可以传递地址来直接修改函数外部的变量。

   void increment(int *ptr) {
       (*ptr)++; // 解引用指针并递增ptr所指向的值
   }
   int num = 10;
   increment(&num); // 传递num的地址给函数

5. 动态内存分配

   可以使用`malloc()`函数动态分配内存。动态分配的内存需要手动释放，以防止内存泄漏。

   int *ptr = (int *)malloc(sizeof(int)); // 动态分配一个int大小的内存块
   if (ptr != NULL) {
       *ptr = 100;
       // 使用ptr指向的内存
       free(ptr); // 释放动态分配的内存
   }

       指针是C语言中强大而灵活的工具，可以用于处理数据结构、字符串、函数调用等多种情况。使用指针需要注意内存安全问题，确保指针不会引用无效的内存地址或释放后的内存。正确使用指针可以提高程序的效率并充分利用内存资源。

2. 动态内存分配和释放

动态内存分配和释放是在程序运行时用于管理内存的重要概念。在C语言中，动态内存分配和释放是通过以下两个函数来实现的：

1. 动态内存分配 - `malloc`函数：

• `malloc`函数用于在运行时分配指定大小的内存空间。
• 其语法为：`void* malloc(size_t size);`
• `size`参数表示需要分配的字节数。
• `malloc`函数返回一个指向分配内存的指针，如果分配失败，则返回空指针（`NULL`）。

示例：

     int *ptr;
     ptr = (int*) malloc(5 * sizeof(int));  // 动态分配了可以存储5个整数的内存
     if (ptr == NULL) {
         // 内存分配失败的处理逻辑
     } else {
         // 内存分配成功，可以使用ptr指针访问分配的内存空间
         // 在完成使用后，必须通过释放内存函数free来释放这块内存
     }

2. 动态内存释放 `free`函数：

• `free`函数用于释放通过动态内存分配函数分配的内存空间。
• 其语法为：`void free(void* ptr);`
• `ptr`参数是指向要释放的内存块的指针。
• 被释放的内存块会返回给系统，可供其它程序使用。

示例：

     int *ptr;
     ptr = (int*) malloc(5 * sizeof(int));  // 动态分配了可以存储5个整数的内存
     if (ptr != NULL) {
         // 在完成使用后，必须通过free函数释放内存
         free(ptr);
         ptr = NULL;  // 将指针置为空，以防止悬空指针的发生（使用已释放的内存）
     }

      需要注意的是，在使用动态内存分配时，需要确保在不再使用分配的内存后释放它，以避免内存泄漏（内存被占用未释放）的问题。另外，在调用`free`函数之后，应将指针置为`NULL`，以避免出现悬空指针（指向已被释放内存）的问题。

正确使用动态内存分配和释放可以帮助我们灵活地管理内存，有效地利用计算机系统资源。

6. 指针和数组的关系

指针和数组在C语言中有着密切的关系，可以相互转换和交互使用。下面是指针和数组的关系的一些重要方面：

1. 数组名是指向数组第一个元素的指针：

• - 在C语言中，数组名被视为指向数组第一个元素的指针。这意味着可以使用指针操作符（*）来访问数组的元素，通过指针算术运算来遍历数组。
• - 示例：

     int arr[5] = {1, 2, 3, 4, 5};
     int *ptr = arr; // 数组名被视为指向数组第一个元素的指针
     
     // 使用指针访问数组元素
     printf("%d\n", *ptr); // 输出：1
     
     // 使用指针算术运算遍历数组
     for (int i = 0; i < 5; i++) {
         printf("%d ", *(ptr + i)); // 输出：1 2 3 4 5
     }

2. 数组作为函数参数是传递的指针：

•  当将数组作为函数的参数传递时，实际上传递的是数组的指针（指向数组第一个元素的指针）。
•  在函数内部，可以使用指针来操作传递的数组，甚至可以修改原始数组的值。

示例：

     void printArray(int *arr, int size) {
         for (int i = 0; i < size; i++) {
             printf("%d ", arr[i]);
         }
     }
  
     int main() {
         int arr[5] = {1, 2, 3, 4, 5};
         printArray(arr, 5); // 将数组作为指针传递给函数
         return 0;
     }

3. 数组和指针之间可以互相转换：

• 数组名可以被隐式转换为指向数组第一个元素的指针，也可以使用`&`运算符来获取数组的地址。
•  指向数组的指针可以通过解引用操作符（*）来访问数组元素。

示例:

     int arr[5] = {1, 2, 3, 4, 5};
     int *ptr = &(arr[0]); // 获取数组的地址并赋给指针
     
     // 通过指针访问数组元素
     printf("%d\n", *ptr); // 输出：1
     
     // 数组名被转换为指针
     printf("%d\n", *arr); // 输出：1

4. 多级指针和指向指针的指针

多级指针（或指向指针的指针）是一种特殊的指针，它指向的是另一个指针的地址。通过多级指针，我们可以间接访问和修改指针的指针所指向的值

下面是指向指针的指针的一些关键概念和操作

1. 定义和声明多级指针：

- 使用多个`*`符号来定义多级指针。

- 示例：

     int value = 10;
     int *ptr = &value;
     int **ptrToPtr = &ptr; // 定义指向指针的指针

2. 通过多级指针访问和修改值：

- 使用多个解引用操作符（*）来访问多级指针指向的值，每个解引用操作符对应一个指针级别。

- 示例：

     int value = 10;
     int *ptr = &value;
     int **ptrToPtr = &ptr;
     
     // 通过多级指针访问和修改值
     printf("%d\n", **ptrToPtr); // 输出：10
     **ptrToPtr = 20;
     printf("%d\n", *ptr); // 输出：20

3. 动态分配多级指针：

- 可以使用多级指针来实现动态内存管理，分配和释放多级指针需要使用相应的内存分配和释放函数

     int value = 10;
     int *ptr = &value;
     int **ptrToPtr = (int**) malloc(sizeof(int*)); // 动态分配指向指针的指针
     *ptrToPtr = ptr;
     
     // 使用动态分配的多级指针访问和修改值
     printf("%d\n", **ptrToPtr); // 输出：10
     **ptrToPtr = 20;
     printf("%d\n", *ptr); // 输出：20
     
     // 释放动态分配的多级指针
     free(ptrToPtr);

多级指针（指向指针的指针）通常用于传递指针的地址，以修改指针本身的值，或者用于指向指针数组的元素，以实现更高级别的数据结构和算法。在使用动态分配的多级指针时，务必记得释放分配的内存。

5. 动态内存分配算法和内存泄漏的预防

动态内存分配是在程序运行时动态地分配和管理内存空间的过程。为了有效地使用内存，避免内存泄漏和提高程序的性能，下面介绍几种常见的动态内存分配算法和内存泄漏的预防方法。

1. 动态内存分配算法：

- 常见的动态内存分配算法包括首次适应算法（First Fit）、最佳适应算法（Best Fit）和最坏适应算法（Worst Fit）等。

- 首次适应算法选择第一个满足大小要求的内存块分配给请求，最佳适应算法选择最小的足够大的内存块分配给请求，最坏适应算法选择最大的足够大的内存块分配给请求。

- 不同的算法有不同的优缺点，选择适合场景的算法可以提高内存的利用率和分配效率。

2. 内存泄漏的预防：

- 内存泄漏是指程序动态分配的内存未能被正确释放，导致内存资源无法再被使用的情况。

- 预防内存泄漏的方法包括：

- 确保每次动态分配内存后，都要在不再使用时进行正确的释放。使用`free()`函数释放通过`malloc()`、`calloc()`、`realloc()`等函数分配的内存。

- 在使用指针指向的内存前，先进行有效性检查，确保指针非空。

- 避免多次释

同一块内存的情况，可以通过设置指针为`NULL`来避免野指针的使用。

- 对于复杂的数据结构，如链表、树等，要小心处理每个节点的内存释放，避免遗漏子节点或其他相关内存的释放。

- 借助内存泄漏检测工具（如Valgrind、AddressSanitizer等），可以帮助发现程序中潜在的内存泄漏问题。

- 定期进行代码审查和测试，特别是针对动态内存分配的部分，以确保没有内存泄漏问题。

使用适当的动态内存分配算法和遵守内存泄漏的预防措施可以保证程序的内存管理健壮性和高效性。为了编写可靠的代码，开发者应该关注内存的分配和释放，并及时修复可能引入内存泄漏的问题。