智能指针的初步探索-优快云博客

本文链接：https://blog.youkuaiyun.com/qq_46243318/article/details/145173799

这段代码展示了如何在C++中使用动态内存分配（堆内存）来创建、使用和释放一个整数。下面将逐行详细解释这段代码的功能和工作原理。

#include <iostream>
using namespace std;

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

int main() {
    int *p = func();
    cout << *p << endl;
    cout << *p << endl;
    // 利用delete释放堆区数据
    delete p;
    // cout << *p << endl; // 报错，释放的空间不可访问
    system("pause");
    return 0;
}

1. 头文件和命名空间

#include <iostream>
using namespace std;

#include <iostream>: 引入标准输入输出流库，允许使用 cout 和 endl。
using namespace std;: 使用标准命名空间，避免每次使用标准库成员时都加上 std:: 前缀。

2. 函数 `func` 的定义

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

返回类型 int*: 该函数返回一个指向整数的指针。
new int(10):
- new 操作符在堆（动态内存）上分配一个整数空间，并初始化为 10。
- 返回一个指向该整数的指针。
int* a: 声明一个指针 a，指向新分配的整数。
return a;: 返回指针 a，使得调用者可以访问该动态分配的整数。

3. `main` 函数

int main() {
    int *p = func();
    cout << *p << endl;
    cout << *p << endl;
    // 利用delete释放堆区数据
    delete p;
    // cout << *p << endl; // 报错，释放的空间不可访问
    system("pause");
    return 0;
}

a. 调用 `func` 并接收返回值

int *p = func();

调用 func 函数，返回一个指向堆上分配的整数的指针，并将其赋值给指针 p。

b. 输出指针 `p` 指向的值

cout << *p << endl;
cout << *p << endl;

*p 解引用指针，访问指针 p 所指向的整数值。
两次输出相同的值 10，因为 p 指向的内容没有改变。

c. 释放动态分配的内存

delete p;

delete 操作符: 释放之前通过 new 分配的内存，防止内存泄漏。
释放后，指针 p 仍然存在，但指向的内存已被释放，不再有效。

d. 注释掉的代码

// cout << *p << endl; // 报错，释放的空间不可访问

这行代码被注释掉，是因为在 delete p; 之后再解引用 p 是未定义行为（UB），可能导致程序崩溃或输出错误数据。
试图访问已释放的内存是错误的，会导致程序不稳定或崩溃。

e. 暂停程序

system("pause");

system("pause"): 在Windows系统上，暂停程序的执行，等待用户按下任意键。这通常用于在控制台应用程序结束前让用户看到输出结果。

f. 返回 0

return 0;

表示程序正常结束。

4. 内存管理的重要性

这段代码展示了手动管理动态内存的基本方法，但也有一些需要注意的地方：

内存泄漏: 如果不使用 delete 释放通过 new 分配的内存，会导致内存泄漏，即程序在运行期间占用的内存不断增加，可能导致系统性能下降甚至崩溃。
悬空指针（Dangling Pointer）: 在 delete p; 之后，指针 p 仍然存在，但指向的内存已被释放。如果继续使用 p（如尝试解引用），会导致未定义行为。因此，良好的实践是在删除指针后将其设置为 nullptr：
```
delete p;
p = nullptr;
```

5. 现代C++中的改进

现代C++（C++11及以后）引入了智能指针，简化了内存管理，减少了内存泄漏和悬空指针的问题。以下是使用 std::unique_ptr 改写上述代码的示例：

#include <iostream>
#include <memory>
using namespace std;

unique_ptr<int> func()
{
    return make_unique<int>(10);
}

int main() {
    unique_ptr<int> p = func();
    cout << *p << endl;
    cout << *p << endl;
    // 不需要手动调用 delete，unique_ptr 会在超出作用域时自动释放内存
    // cout << *p << endl; // 这里 p 仍然有效，且内存已被正确管理
    system("pause");
    return 0;
}

std::unique_ptr: 智能指针，负责自动管理动态分配的内存，当 unique_ptr 超出作用域时，会自动调用 delete 释放内存。
make_unique<int>(10): 创建一个 unique_ptr，指向一个初始化为 10 的整数。
这样可以避免手动管理内存，减少错误的可能性。

总结

这段代码通过动态内存分配演示了指针的使用和内存管理的重要性。关键点包括：

动态内存分配: 使用 new 在堆上分配内存。
指针操作: 使用指针访问和操作动态分配的内存。
内存释放: 使用 delete 释放分配的内存，防止内存泄漏。
避免悬空指针: 在释放内存后，不再使用该指针，或将其设置为 nullptr。
现代C++改进: 使用智能指针（如 std::unique_ptr）简化内存管理，提高代码安全性和可维护性。

理解和正确管理动态内存对于编写高效和安全的C++程序至关重要。

在您提到的智能指针（std::unique_ptr）版本的代码中，注释掉的那一行代码：

// cout << *p << endl; // 这里 p 仍然有效，且内存已被正确管理

之所以被认为是“有效的”，是因为在智能指针管理下，指针 p 依然保持有效，并且所指向的内存也仍然被正确管理和保留，直到 unique_ptr 超出其作用域或被显式重置。这与原始指针在手动 delete 后成为悬空指针不同。

详细解释

让我们回顾一下使用智能指针的代码：

#include <iostream>
#include <memory>
using namespace std;

unique_ptr<int> func()
{
    return make_unique<int>(10);
}

int main() {
    unique_ptr<int> p = func();
    cout << *p << endl; // 输出 10
    cout << *p << endl; // 再次输出 10
    // 不需要手动调用 delete，unique_ptr 会在超出作用域时自动释放内存
    // cout << *p << endl; // 这里 p 仍然有效，且内存已被正确管理
    system("pause");
    return 0;
}

1. 智能指针 `std::unique_ptr`

std::unique_ptr<int> p: unique_ptr 是一种智能指针，用于独占拥有动态分配的对象。当 unique_ptr 被销毁时（例如，超出其作用域），它会自动调用 delete 来释放所管理的内存。
make_unique<int>(10): 这是一个工厂函数，用于创建一个 unique_ptr，并初始化其所管理的对象（在这里是一个值为 10 的整数）。

2. 为什么 `cout << *p << endl;` 仍然有效

在智能指针管理下，以下几点确保了指针 p 以及所指向的内存的有效性：

生命周期管理: unique_ptr 会在其生命周期结束时自动释放内存。在 main 函数的作用域内，p 一直保持有效，直到 main 函数结束。
自动释放: 不需要手动调用 delete，这减少了人为错误（如忘记释放内存或重复释放）的风险。
悬空指针避免: 因为 unique_ptr 自动管理内存，当 p 超出作用域时，内存被安全地释放，避免了悬空指针的问题。

在上述代码中，注释掉的那一行：

// cout << *p << endl; // 这里 p 仍然有效，且内存已被正确管理

如果将其取消注释并放在 main 函数的当前作用域内，它仍然是有效的，因为 unique_ptr p 仍然持有对内存的所有权，且内存尚未被释放。因此，解引用 *p 是安全的。

3. 对比原始指针版本

在原始指针版本中：

int main() {
    int *p = func();
    cout << *p << endl;
    cout << *p << endl;
    delete p;
    // cout << *p << endl; // 报错，释放的空间不可访问
    system("pause");
    return 0;
}

手动管理内存: 需要显式调用 delete 来释放内存。如果在 delete p; 之后再次尝试 cout << *p << endl;，会导致未定义行为，因为 p 成为了悬空指针，指向的内存已被释放。

而在智能指针版本中：

无需手动 delete: 内存释放由 unique_ptr 自动管理，确保了资源的正确释放。
指针仍然有效: 在 unique_ptr 管理下，只要 unique_ptr 还在作用域内且未被重置，指针 p 始终有效，且指向的内存仍然可访问。

4. 总结

智能指针的优势:
- 自动管理资源，减少内存泄漏的风险。
- 避免悬空指针问题。
- 代码更简洁，易于维护。
为什么注释的 cout << *p << endl; 仍然有效:
- 因为在智能指针版本中，内存的释放时机由 unique_ptr 控制，而不是手动调用 delete。
- 只要 unique_ptr p 仍然存在且未被销毁，所指向的内存依然有效，可以安全地解引用。