编辑“︁C++ 从函数返回指针”︁

{{DISPLAYTITLE:C++从函数返回指针}}

== 介绍 ==
在C++中，指针是一种强大的工具，它允许程序员直接操作内存地址。从函数返回指针是一个重要的概念，它使得函数能够返回动态分配的内存或特定变量的地址，从而在程序的其他部分继续使用这些数据。然而，这一技术需要谨慎使用，因为不当的内存管理可能导致内存泄漏或悬空指针等问题。

== 基本语法 ==
从函数返回指针的基本语法如下：
<syntaxhighlight lang="cpp">
返回类型* 函数名(参数列表) {
    // 函数体
    return 指针;
}
</syntaxhighlight>

== 返回局部变量的指针 ==
初学者常犯的一个错误是返回局部变量的指针。由于局部变量在函数结束时会被销毁，返回其指针会导致未定义行为。

=== 错误示例 ===
<syntaxhighlight lang="cpp">
int* getLocalPointer() {
    int x = 10;
    return &x;  // 错误：返回局部变量的地址
}

int main() {
    int* ptr = getLocalPointer();
    cout << *ptr;  // 未定义行为
    return 0;
}
</syntaxhighlight>

== 正确返回指针的方法 ==

=== 返回动态分配的内存 ===
使用`new`运算符在堆上分配内存，这样内存在函数返回后仍然有效。

<syntaxhighlight lang="cpp">
int* createArray(int size) {
    int* arr = new int[size];
    for (int i = 0; i < size; ++i) {
        arr[i] = i * i;
    }
    return arr;
}

int main() {
    int* myArray = createArray(5);
    for (int i = 0; i < 5; ++i) {
        cout << myArray[i] << " ";
    }
    delete[] myArray;  // 记得释放内存
    return 0;
}
</syntaxhighlight>

输出：
<pre>
0 1 4 9 16 
</pre>

=== 返回静态变量的指针 ===
静态变量在程序的生命周期内都存在，因此可以安全地返回其指针。

<syntaxhighlight lang="cpp">
int* getStaticPointer() {
    static int x = 42;
    return &x;
}

int main() {
    int* ptr = getStaticPointer();
    cout << *ptr;  // 输出42
    return 0;
}
</syntaxhighlight>

=== 返回传入参数的指针 ===
函数可以安全地返回传入参数的指针，前提是这些参数本身不是局部变量。

<syntaxhighlight lang="cpp">
int* max(int* a, int* b) {
    return (*a > *b) ? a : b;
}

int main() {
    int x = 10, y = 20;
    int* result = max(&x, &y);
    cout << *result;  // 输出20
    return 0;
}
</syntaxhighlight>

== 智能指针（高级主题） ==
现代C++推荐使用智能指针来管理动态内存，避免内存泄漏。

=== 使用`std::unique_ptr` ===
<syntaxhighlight lang="cpp">
#include <memory>

std::unique_ptr<int[]> createSmartArray(int size) {
    auto arr = std::make_unique<int[]>(size);
    for (int i = 0; i < size; ++i) {
        arr[i] = i * i;
    }
    return arr;
}

int main() {
    auto myArray = createSmartArray(5);
    for (int i = 0; i < 5; ++i) {
        cout << myArray[i] << " ";
    }
    // 不需要手动delete，unique_ptr会自动释放内存
    return 0;
}
</syntaxhighlight>

== 实际应用案例 ==

=== 工厂模式 ===
在面向对象编程中，工厂函数经常返回指向新创建对象的指针。

<syntaxhighlight lang="cpp">
class Shape {
public:
    virtual void draw() = 0;
    virtual ~Shape() {}
};

class Circle : public Shape {
public:
    void draw() override { cout << "Drawing Circle\n"; }
};

class Square : public Shape {
public:
    void draw() override { cout << "Drawing Square\n"; }
};

Shape* createShape(char type) {
    switch(type) {
        case 'c': return new Circle();
        case 's': return new Square();
        default: return nullptr;
    }
}

int main() {
    Shape* shape = createShape('c');
    if (shape) {
        shape->draw();  // 输出: Drawing Circle
        delete shape;
    }
    return 0;
}
</syntaxhighlight>

== 内存管理注意事项 ==
<mermaid>
graph TD
    A[函数返回指针] --> B{指针指向什么?}
    B -->|局部变量| C[危险: 悬空指针]
    B -->|动态分配| D[需要手动释放]
    B -->|静态变量| E[安全]
    B -->|参数指针| F[安全]
</mermaid>

== 数学表示 ==
从函数返回指针可以表示为：
<math>f: P \rightarrow P^*</math>
其中：
* <math>P</math> 是参数空间
* <math>P^*</math> 是指针空间

== 总结 ==
从函数返回指针是C++中一个强大但需要谨慎使用的特性。关键点包括：
* 永远不要返回局部变量的指针
* 动态分配的内存需要记得释放
* 考虑使用智能指针进行现代C++编程
* 静态变量和传入参数的指针可以安全返回

通过正确使用这些技术，你可以编写出高效且安全的C++代码。

[[Category:编程语言]]
[[Category:C++]]
[[Category:C++ 指针]]