C语言使用指针的15大陷阱

C语言使用指针的15大陷阱

引用

CSDN

1.

https://blog.csdn.net/alittlehippo/article/details/144017721

1. 未初始化指针

• 陷阱描述：如果定义一个指针后没有对其初始化就进行解引用操作，会导致程序访问到非法的内存地址，这是非常危险的，可能会使程序崩溃或者产生不可预测的行为。例如：

  int *p;
  *p = 10; // 未初始化的指针p，这里解引用会出错
  

• 解决方法：在定义指针时，要么将其初始化为 NULL ，要么让它指向一个有效的内存地址，如已经分配好的变量地址或者动态分配的内存。例如：

  int a = 5;
  int *p = &a; // p指向变量a的地址
  

  或者

  int *p = NULL;
  

2. 指针越界访问数组

• 陷阱描述：当使用指针遍历数组时，如果不小心让指针超出了数组的边界，就会访问到数组之外的内存区域。例如：

  int arr[5] = {1, 2, 3, 4, 5};
  int *p = arr;
  for (int i = 0; i <= 5; i++) {
    printf("%d ", *p++); // 当i = 5时，p超出数组边界
  }
  

• 解决方法：确保指针在遍历数组时不会超出数组的有效范围。在上面的例子中，循环条件应该是 i < 5 ，而不是 i <= 5 。

3. 释放非堆内存的指针

• 陷阱描述：试图释放栈上分配的内存（例如局部变量的地址）会导致程序错误。例如：

  void func() {
    int a = 10;
    int *p = &a;
    free(p); // 错误，不能释放栈内存
  }
  

• 解决方法：只释放通过 malloc 、 calloc 或 realloc 等函数在堆上分配的内存。例如：

  int *p = (int *)malloc(sizeof(int));
  // 使用p
  free(p);
  

4. 悬空指针（Dangling Pointer）

• 陷阱描述：当所指向的对象被释放后，指针仍然存在，这种指针称为悬空指针。如果继续使用悬空指针，会导致访问已经释放的内存，产生不可预测的结果。例如：

  int *p = (int *)malloc(sizeof(int));
  free(p);
  *p = 10; // p是悬空指针，这里会出错
  

• 解决方法：在释放指针所指向的内存后，将指针赋值为 NULL 。这样，在使用指针之前可以先检查它是否为 NULL ，避免意外访问已释放的内存。例如：

  int *p = (int *)malloc(sizeof(int));
  free(p);
  p = NULL;
  if (p != NULL) {
    *p = 10;
  }
  

5. 错误的指针类型转换

• 陷阱描述：在C语言中，指针类型转换可能会导致数据访问和解释的错误。例如，将一个 float * 指针强制转换为 int * 指针并进行访问，会按照 int 的格式来解释原本按照 float 存储的数据。

  float f = 3.14;
  float *fp = &f;
  int *ip = (int *)fp;
  printf("%d\n", *ip); // 错误的解释数据
  

• 解决方法：谨慎进行指针类型转换，只有在确定转换是合理的并且清楚转换后的行为时才进行转换。如果需要访问不同类型的数据，应该使用正确的类型指针和适当的内存访问方式。

6. 返回局部变量的地址

• 陷阱描述：当一个函数返回一个局部变量的地址时，由于局部变量在函数结束后就会被销毁，返回的地址指向的内存可能已经被重新分配或者无效。例如：

  int *func() {
    int a = 10;
    return &a;
  }
  int main() {
    int *p = func();
    printf("%d\n", *p); // 可能得到错误的值或者程序崩溃
  }
  

• 解决方法：如果需要返回一个变量的地址，应该确保该变量在函数返回后仍然有效。可以将变量定义为静态变量（ static ）或者通过动态分配内存（ malloc 等）来实现。例如：

  int *func() {
    static int a = 10;
    return &a;
  }
  

  或者

  int *func() {
    int *p = (int *)malloc(sizeof(int));
    *p = 10;
    return p;
  }
  

7. 多级指针的错误赋值

• 陷阱描述：在使用多级指针时，容易出现赋值错误。例如，对于二级指针 int **pp ，如果错误地将一个普通指针的值赋给它，而不是另一个指针的地址，会导致程序逻辑错误。

  int a = 10;
  int *p = &a;
  int **pp;
  pp = p; // 错误，应该是pp = &p;
  

• 解决方法：理解多级指针的概念，在赋值时确保正确的层次关系。对于二级指针，应该将一级指针的地址赋给它。例如：

  int a = 10;
  int *p = &a;
  int **pp = &p;
  

8. 指针运算错误

• 陷阱描述：指针运算的规则比较复杂，特别是涉及到不同类型的指针和数组。例如，对一个 char * 指针进行加法运算时，如果错误地按照 int 类型的步长进行计算，会导致访问错误的内存位置。

  char str[] = "Hello";
  char *p = str;
  p = p + sizeof(int); // 错误的指针运算，步长错误
  

• 解决方法：正确理解指针运算的规则。对于指针加法和减法，其步长是根据指针所指向的数据类型来确定的。在上面的例子中， p = p + 1 是正确的操作，它会使指针指向下一个 char 元素。

9. 混淆指针和数组名的性质

• 陷阱描述：虽然数组名在很多情况下可以像指针一样使用，但它们之间还是有区别的。例如，数组名是一个常量指针，不能对其进行赋值操作，而指针可以。

  int arr[5];
  arr = NULL; // 错误，数组名不能赋值
  int *p = arr;
  p = NULL; // 正确，指针可以赋值
  

• 解决方法：清楚数组名和指针的不同性质。在需要修改指针所指向的位置时，使用指针；而在使用数组的固定名称来访问数组元素时，注意不要对数组名进行不适当的操作。

10. 忽视指针的字节对齐问题

• 陷阱描述：在一些硬件平台或者编译器设置下，数据存储有字节对齐的要求。如果指针访问的数据没有正确对齐，可能会导致性能下降甚至程序错误。例如，在某些架构中， double 类型的数据要求按8字节对齐，如果一个 double * 指针指向的内存地址不是8的倍数，可能会出现问题。

• 解决方法：了解目标平台的字节对齐要求。在分配内存和使用指针访问数据时，尽量保证数据的存储满足字节对齐条件。有些编译器提供了对齐属性（如 attribute((aligned(n))) ）来帮助控制数据的对齐。

11. 错误地比较指针

• 陷阱描述：比较两个不相关的指针（指向不同的内存区域，如不同的数组）可能会得到不符合预期的结果。例如，比较一个数组的指针和另一个无关数组的指针来判断元素大小是没有意义的。

  int arr1[5] = {1, 2, 3, 4, 5};
  int arr2[3] = {6, 7, 8};
  int *p1 = arr1;
  int *p2 = arr2;
  if (p1 < p2) { // 无意义的比较
    //...
  }
  

• 解决方法：只在有意义的情况下比较指针，比如比较指向同一数组的不同元素的指针，用于判断元素的顺序或者范围。例如，在遍历数组时，比较指针是否到达数组末尾。

12. 忘记分配足够的内存给指针

• 陷阱描述：当使用指针存储字符串或者其他数据结构时，如果没有分配足够的内存，会导致数据溢出。例如，使用 strcpy 函数将一个较长的字符串复制到一个没有足够空间的字符指针所指向的区域。

  char *p;
  strcpy(p, "This is a long string"); // 错误，p没有分配内存
  

• 解决方法：在使用指针存储数据之前，先确保为其分配足够的内存。对于字符串，可以使用 strlen 函数计算字符串长度，然后分配足够的空间（包括字符串结束符 '\0' ）。例如：

  char *p = (char *)malloc(strlen("This is a long string") + 1);
  strcpy(p, "This is a long string");
  

13. 重复释放指针

• 陷阱描述：对已经释放过的指针再次进行释放操作会导致程序错误。例如：

  int *p = (int *)malloc(sizeof(int));
  free(p);
  free(p); // 错误，重复释放
  

• 解决方法：在释放指针后，将指针赋值为 NULL ，并且在释放之前检查指针是否已经为 NULL 。这样可以避免重复释放的问题。例如：

  int *p = (int *)malloc(sizeof(int));
  if (p != NULL) {
    free(p);
    p = NULL;
  }
  if (p != NULL) {
    free(p);
  }
  

14. 误解指针数组和数组指针

• 陷阱描述：指针数组（ int *arr[5] ）和数组指针（ int (*arr)[5] ）是不同的概念。指针数组是一个数组，其元素是指针；而数组指针是一个指针，它指向一个数组。混淆这两者会导致程序逻辑错误。例如，在访问元素或者传递参数时可能会出现问题。

  int *arr1[5]; // 指针数组
  int (*arr2)[5]; // 数组指针
  int a[5] = {1, 2, 3, 4, 5};
  arr2 = &a; // 正确，将数组a的地址赋给数组指针
  arr1 = &a; // 错误，类型不匹配
  

• 解决方法：仔细区分指针数组和数组指针的语法和用途。在定义和使用时，根据实际需求选择正确的类型。如果要存储多个指针，使用指针数组；如果要指向一个数组，使用数组指针。

15. 错误地使用指针作为函数参数

• 陷阱描述：在函数中，如果只是将指针作为参数传递，而没有考虑到函数内部对指针所指向的数据的修改是否需要反馈给调用者，可能会导致问题。例如，只是传递了一个指针的副本，函数内部对指针的修改（如重新赋值）不会影响到调用者的指针。

  void func(int *p) {
    int a = 10;
    p = &a; // 函数内部修改p，不会影响调用者的指针
  }
  int main() {
    int b = 5;
    int *q = &b;
    func(q);
    printf("%d\n", *q); // 仍然输出5，没有被函数修改
  }
  

• 解决方法：如果需要函数内部对指针的修改（如重新赋值）能够影响到调用者，需要传递指针的地址（二级指针）。或者，如果只是需要修改指针所指向的数据，可以在函数内部通过解引用指针来操作数据。例如：

  void func(int **pp) {
    int a = 10;
    *pp = &a; // 修改调用者的指针
  }
  // 或者
  void func(int *p) {
    *p = 10; // 修改指针所指向的数据
  }