【C++】智能指针 & 裸指针 & 悬挂指针

1、智能指针

智能指针是 C++ 标准库提供的模板类，用于自动管理动态分配的内存，以避免内存泄露和其他与裸指针相关的问题。智能指针通过在对象生命周期结束时自动释放其指向的内存来实现资源管理。C++ 标准库中最常用的智能指针包括 std::unique_ptr、std::shared_ptr 和 std::weak_ptr。

std::shared_ptr

引用计数：std::shared_ptr 使用引用计数机制，可以有多个 shared_ptr 实例指向同一个对象。当最后一个这样的实例被销毁或重置时，它指向的对象也会被自动销毁。
线程安全：修改指针本身的操作（如复制和赋值）是线程安全的，但访问所指向的对象的操作不是线程安全的。
用法示例：

#include <memory>

struct MyObject {
    int data;
    ~MyObject() { std::cout << "MyObject destroyed\n"; }
};

int main() {
    std::shared_ptr<MyObject> ptr1 = std::make_shared<MyObject>();
    {
        std::shared_ptr<MyObject> ptr2 = ptr1; // 两个shared_ptr现在管理同一个对象
    } // ptr2超出范围并被销毁，但MyObject不会被删除，因为ptr1仍然存在

    return 0; // 现在ptr1也将被销毁，所以它管理的MyObject会被销毁
}

在这个例子中，MyObject 的实例由两个 std::shared_ptr 管理，确保了当最后一个指针销毁时，对象得到正确的清理。

总之，内联函数主要用于提高小型函数的效率，而智能指针则用于自动化内存管理，减少内存泄露和资源管理错误。

std::make_shared

std::make_shared 是 C++11 引入的一个函数模板，用于创建一个 std::shared_ptr 智能指针。使用 std::make_shared 创建 std::shared_ptr 比直接使用 std::shared_ptr 的构造函数（配合 new 操作符）具有多方面的优势：

优点

效率更高：
std::make_shared 在单个内存分配中同时分配控制块（包含引用计数和其他元数据）和对象本身。这比分别为对象和控制块进行的两次内存分配（使用 new 时常见）更高效。这种方式可以减少内存分配次数并提高内存局部性，可能导致更好的缓存性能。

异常安全：
使用 std::make_shared 可以避免某些由于构造函数抛出异常而导致的内存泄漏问题。例如，在将新创建的对象传递给函数时，如果使用裸指针和 new，可能在构造 std::shared_ptr 之前发生异常，从而导致分配的内存无法释放。
std::make_shared 通过在分配内存和构造对象之前捕获任何可能的异常来保证这种安全性。

使用示例
假设有一个类 MyClass，你可以使用 std::make_shared 来创建一个指向 MyClass 的 std::shared_ptr：

#include <memory>

class MyClass {
public:
    MyClass(int x, double y) : data(x), value(y) {}
    int data;
    double value;
};

int main() {
    // 使用 make_shared 创建一个 MyClass 的实例
    std::shared_ptr<MyClass> p = std::make_shared<MyClass>(10, 3.14);

    // 现在 p 是指向 MyClass 的智能指针，自动管理 MyClass 的生命周期
    return 0;
}

在这个示例中，MyClass 的对象通过 std::make_shared 被创建，并且 p 自动接管了内存管理的责任。这种方式是创建和使用 std::shared_ptr 的推荐做法，尤其是当对象需要被多个指针共享时。

总结

std::make_shared 是创建 std::shared_ptr 的一个有效且安全的方法，它通过优化内存使用和增强异常安全性，为现代 C++ 应用提供了重要的工具。使用 std::make_shared 不仅可以简化代码，还可以提高程序的性能和可靠性。

2、裸指针

裸指针（Raw Pointer）是指在 C 和 C++ 语言中最基本的指针类型，直接存储内存地址的指针。裸指针由指针变量直接表示，可以指向任何类型的数据或函数。在 C++ 中，裸指针通常用于指向动态分配（通常使用 new 或 malloc）的内存。

特性

灵活性：裸指针提供对内存的直接访问，可以用于访问数组、动态分配的内存、操作硬件设备的内存映射区域等。
危险性：裸指针的使用不当容易导致内存泄漏、访问已释放内存、空指针解引用等错误。这些错误往往难以追踪和调试。
管理责任：使用裸指针时，程序员必须手动管理内存的分配和释放，这包括在正确的时间调用 delete 或 free。

使用示例

在这个示例中，我将演示如何使用裸指针进行动态内存分配和释放：

#include <iostream>

class MyClass {
public:
    int data;
    MyClass(int val) : data(val) {
        std::cout << "MyClass constructed with data = " << data << std::endl;
    }
    ~MyClass() {
        std::cout << "MyClass destroyed" << std::endl;
    }
};

int main() {
    MyClass* p = new MyClass(10);  // 使用 new 关键字动态分配内存

    std::cout << "Data in MyClass: " << p->data << std::endl;

    delete p;  // 释放内存
    p = nullptr;  // 将指针设为 nullptr，避免悬挂指针

    return 0;
}

在这个代码中，MyClass 对象通过 new 被动态创建，并通过 delete 显式释放。将指针设为 nullptr 是一个好习惯，可以防止悬挂指针的错误使用。

使用裸指针的问题

内存泄漏：如果忘记释放通过 new 分配的内存，那么这部分内存将无法被其他程序使用，直到程序结束。这种现象称为内存泄漏。
悬挂指针：如果内存被释放后，仍有指针指向该内存地址，这种指针称为悬挂指针。悬挂指针的使用可能导致程序崩溃或数据损坏。
多重删除：对同一个内存地址调用多次 delete 可能导致程序行为不稳定或崩溃。
边界问题：裸指针常用于数组操作，但它们不会检查数组边界，可能导致数组越界等安全问题。

裸指针和智能指针的比较

安全性：智能指针如 std::shared_ptr 提供了更高的安全性，减少了内存泄漏和资源管理错误的风险。
易用性：智能指针的使用比裸指针简单，尤其是在复杂的程序或库中，使用智能指针可以显著减少管理资源的复杂性。
性能：智能指针（尤其是 std::shared_ptr）有一些性能开销，如引用计数的管理。然而，对于大多数应用，这种开销是可以接受的，鉴于它带来的安全性和易用性优势。

总结来说，虽然裸指针在某些底层编程场景中仍然必要，但在现代 C++ 编程中，推荐使用智能指针来简化资源管理并增加代码的健壞性。

3、悬挂引用

悬挂引用（dangling reference）是一个常见的错误，它发生在引用指向的对象被销毁或已经超出其作用域，而引用本身还在被使用的情况下。这会导致未定义的行为，因为引用指向的内存已经不再有效。

下面是一个具体的示例，演示如何意外地创建悬挂引用，并展示其潜在危险。

示例：悬挂引用的创建和错误

#include <iostream>

int& createDanglingReference() {
    int localValue = 100;
    return localValue; // 返回局部变量的引用
}

int main() {
    int& danglingRef = createDanglingReference(); // 接收一个悬挂引用
    // 注意：此时 localValue 已经离开了作用域，其内存可能已被回收或重新用于其他用途
    std::cout << "Dangling Reference Value: " << danglingRef << std::endl; // 未定义行为
    return 0;
}

解释：
函数 createDanglingReference 定义了一个局部整型变量 localValue 并初始化为100。然后，它返回这个局部变量的引用。
在 C++ 中，局部变量在函数结束时会被销毁，这意味着 localValue 的内存被释放，而返回的引用指向了一个不再有效的内存位置。
在 main 函数中，通过这个已经无效的引用尝试访问或使用该变量的值将导致未定义行为，因为引用所指向的内存区域可能已经被操作系统回收或用于其他目的。

造成的问题：

内存访问错误：尝试通过悬挂引用访问内存可能导致程序崩溃，或者读取到错误或随机的数据。
安全隐患：在安全敏感的应用中，未定义的行为可能被用于执行恶意代码。

如何避免：

避免返回局部变量的引用或指针：确保你返回的引用或指针指向的是长期存在的对象，比如通过 new 分配的对象、全局/静态对象，或者确保对象的生命周期足以覆盖引用的使用期。
使用智能指针：对于动态分配的内存，使用 std::shared_ptr 或 std::unique_key 可以帮助管理内存的生命周期，减少悬挂引用的风险。
小心函数返回的引用：在设计函数接口时，明确文档说明返回的引用的生命周期和使用条件。