指针函数C++

指针函数概念

指针函数在C++中是一种特殊类型的函数。从本质上讲，它是一个函数，不过其返回值是一个指针类型的数据。例如，像int* plusfunction(int a, int b);这样的函数声明，plusfunction就是一个指针函数，它接受两个int类型的参数，返回值是一个指向int类型的指针。

指针函数的定义形式有助于我们理解它与其他函数类型的区别。它与普通函数的区别在于返回值的类型是指针。这意味着它返回的是一个地址值，这个地址可以指向各种数据类型，如基本数据类型（int、char等）、结构体或者数组等。

在C++的程序设计中，指针函数有着重要的意义。它可以在函数执行完毕后，返回一个动态分配内存的地址，使得在函数外部能够继续对这个内存区域进行操作。例如，当需要在一个函数中创建一个对象，并在函数调用结束后仍然能够访问这个对象时，可以使用指针函数来返回这个对象的地址。另外，指针函数也可以用于返回数组的首地址，从而方便在函数外部对数组进行遍历、修改等操作。不过，使用指针函数时需要特别小心，因为返回的指针如果处理不当，可能会导致悬空指针（指向已经释放的内存）或者野指针（未初始化的指针）等问题，从而引发程序错误或者内存泄漏等严重后果。

指针函数用法示例

以下是一个指针函数的简单用法示例：

#include <iostream>
#include <stdlib.h>
 
// 指针函数，返回值为指向int类型的指针
int* plusfunction(int a, int b) {
    int* p = (int*)malloc(sizeof(int)); 
    *p = a + b; 
    return p; 
}
 
int main() {
    int* p = NULL; 
    p = plusfunction(1, 2); 
    std::cout << "*p is " << *p << std::endl; 
    free(p); 
    return 0; 
}

在这个示例中，plusfunction是一个指针函数，它在函数内部动态分配了一块内存来存储a和b相加的结果，然后返回这个内存的地址（即指向int类型的指针）。在main函数中，首先定义了一个指针p并初始化为NULL，然后调用plusfunction函数，并将返回的指针赋值给p，接着输出p所指向的值，最后释放这块动态分配的内存。

再看一个返回数组首地址的指针函数示例：

#include <iostream>
 
// 指针函数，返回值为指向int数组的指针
int* createArray() {
    static int arr[5] = {1, 2, 3, 4, 5}; 
    return arr; 
}
 
int main() {
    int* p = createArray(); 
    for (int i = 0; i < 5; i++) {
        std::cout << p[i] << " "; 
    }
    return 0; 
}

指针函数常见错误及解决方法

一、返回局部变量的地址

1. 错误描述

   • 当指针函数返回一个局部变量的地址时，会导致严重的错误。例如：

   #include <iostream>
   
   int* wrongFunction() {
       int num = 10; 
       return &num; 
   }
   
   int main() {
       int* p = wrongFunction(); 
       std::cout << *p << std::endl; 
       return 0; 
   }

   在这个例子中，wrongFunction函数试图返回局部变量num的地址。但是，局部变量num在函数结束时就会被销毁，其占用的内存空间会被释放。此时，p就成为了一个悬空指针，访问*p会导致未定义行为，可能会输出错误的值，或者程序直接崩溃。

2. 解决方法

   • 如果需要返回一个变量的地址，可以将变量定义为静态变量。例如：

   #include <iostream>
   
   int* correctFunction() {
       static int num = 10; 
       return &num; 
   }
   
   int main() {
       int* p = correctFunction(); 
       std::cout << *p << std::endl; 
       return 0; 
   }

   这里将num定义为静态变量，静态变量在函数调用结束后不会被销毁，其内存空间仍然保留，所以返回其地址是安全的。

二、未初始化指针的返回

1. 错误描述

   • 如果指针函数返回一个未初始化的指针，这也是一个常见的错误。例如：

   #include <iostream>
   
   int* uninitializedFunction() {
       int* p; 
       return p; 
   }
   
   int main() {
       int* q = uninitializedFunction(); 
       std::cout << *q << std::endl; 
       return 0; 
   }

   在这个例子中，uninitializedFunction函数中的指针p没有被初始化就被返回。这会导致q得到一个未初始化的指针，访问*q同样会导致未定义行为。

2. 解决方法

   • 确保在返回指针之前，指针已经被正确初始化。如果指针是动态分配内存的，例如：

   #include <iostream>
   #include <stdlib.h>
   
   int* initializedFunction() {
       int* p = (int*)malloc(sizeof(int)); 
       *p = 20; 
       return p; 
   }
   
   int main() {
       int* r = initializedFunction(); 
       std::cout << *r << std::endl; 
       free(r); 
       return 0; 
   }

   这里先通过malloc为指针p分配内存并初始化，然后再返回指针。并且在main函数中使用完后，通过free释放内存。

指针函数与普通函数的区别

一、定义形式上的区别

1. 指针函数

   • 指针函数的定义形式为返回值类型* 函数名(参数列表)。例如int* plusfunction(int a, int b);，这里的*与返回值类型int紧密相连，表示函数的返回值是一个指向int类型的指针。指针函数本质上是一个函数，它在函数体中计算出一个结果，然后以指针的形式返回这个结果。

2. 普通函数

   • 普通函数的定义形式为返回值类型 函数名(参数列表)。例如int add(int a, int b)，这个函数直接返回一个int类型的值，而不是一个指针。普通函数返回的是计算结果本身，而不是结果的地址。

二、返回值性质的区别

1. 指针函数

   • 由于指针函数返回的是指针，这就意味着它返回的是一个内存地址。这个地址可以指向不同的数据类型，如基本数据类型、数组、结构体等。例如，一个指针函数可以返回一个动态分配数组的首地址，这样在函数外部就可以通过这个地址访问整个数组。但是，这也带来了更多的风险，如悬空指针和内存泄漏等问题，如果返回的指针所指向的内存没有被正确管理（如动态分配的内存没有释放），就会出现这些问题。

2. 普通函数

   • 普通函数返回的是一个具体的值，这个值可以直接用于表达式的计算、赋值等操作。例如，一个普通函数返回两个数相加的结果，这个结果可以直接赋给一个变量或者作为另一个函数的参数。普通函数不需要担心像指针函数那样的内存管理问题，因为它不涉及到返回地址的操作。

三、函数调用时的区别

1. 指针函数

   • 当调用指针函数时，得到的是一个指针，这个指针需要进行解引用操作才能获取到实际的值。例如：

   int* p = plusfunction(1, 2); 
   std::cout << *p << std::endl; 

   这里首先调用指针函数plusfunction得到一个指向int的指针p，然后通过*p来获取指针所指向的实际值。

2. 普通函数

   • 调用普通函数时，直接得到的就是函数的返回值，可以直接使用这个返回值。例如：

   int result = add(1, 2); 
   std::cout << result << std::endl; 

   这里调用add函数后，直接将返回值赋给变量result，不需要额外的解引用操作。

指针函数性能优化

一、减少指针间接访问

1. 问题分析

   • 指针函数返回指针，在使用返回的指针时涉及到指针间接访问（解引用操作）。过多的指针间接访问会影响性能，因为每次解引用都需要额外的计算来获取指针所指向的值。例如，如果在一个循环中频繁地解引用指针函数返回的指针，会增加CPU的计算开销。

2. 优化方法

   • 如果可能的话，可以将指针函数返回的值缓存起来，减少解引用的次数。例如：

   int* p = pointerFunction(); 
   int value = *p; 
   // 在后续的代码中多次使用value，而不是多次解引用p

   这里先将*p的值赋给value，然后在后续需要使用这个值的地方直接使用value，而不是再次解引用p。

二、合理管理内存

1. 动态内存分配

   • 如果指针函数中涉及到动态内存分配（如malloc等函数），要确保内存的合理使用。避免不必要的内存分配，因为动态内存分配是一个相对耗时的操作。例如，如果一个指针函数在每次调用时都动态分配一块固定大小的内存，而实际上这块内存可以在函数外部一次性分配好，就应该进行优化。

   • 在不需要使用动态分配的内存时，要及时释放。否则会导致内存泄漏，长期运行可能会耗尽系统内存。例如：

   int* pointerFunction() {
       int* p = (int*)malloc(sizeof(int)); 
       // 一些操作
       return p; 
   }
   
   int main() {
       int* result = pointerFunction(); 
       // 使用result
       free(result); 
   }

2. 静态内存使用

   • 在一些情况下，如果指针函数返回的指针所指向的内存不需要动态分配，可以考虑使用静态内存。静态内存的分配在程序启动时就完成了，不需要像动态内存分配那样在运行时进行分配操作，速度相对较快。例如：

   • int* pointerFunction() {
         static int value = 10; 
         return &value; 
     }

   这里返回静态变量的地址，不需要动态分配内存，提高了性能并且避免了内存管理的复杂性。