C++提供的智能指针 unique_ptr、shared_ptr、weak_ptr

C++提供的智能指针 unique_ptr、shared_ptr、weak_ptr

flyfish

曾经的代码是这样写的

delete 用于释放通过 new 分配的单个对象。
delete[] 用于释放通过 new[] 分配的数组。

单个对象的分配和释放 ：

int* p = new int;  // 分配单个int对象
delete p;         // 释放单个int对象

数组的分配和释放 ：

int* arr = new int[10];  // 分配包含10个int的数组
delete[] arr;            // 释放数组

示例

#include <iostream>

class MyClass {
public:
    MyClass() { std::cout << "MyClass created" << std::endl; }
    ~MyClass() { std::cout << "MyClass destroyed" << std::endl; }
};

int main() {
    // 分配和释放单个对象
    MyClass* obj = new MyClass;
    delete obj;

    // 分配和释放数组
    MyClass* arr = new MyClass[3];
    delete[] arr;

    return 0;
}

C++标准库提供了几种智能指针

• std::unique_ptr ：独占所有权智能指针（Unique Ownership Smart Pointer）

• std::shared_ptr ：共享所有权智能指针（Shared Ownership Smart Pointer）

• std::weak_ptr ：弱引用智能指针（Weak Reference Smart Pointer）

1. std::unique_ptr

std::unique_ptr 是一种独占所有权的智能指针，意味着同一时间只有一个 std::unique_ptr 拥有某个对象的所有权。它在离开作用域时会自动释放所管理的对象。
使用场景 ：
独占所有权：当一个对象只能有一个所有者时，使用 std::unique_ptr。
高效转移所有权：通过 std::move 可以高效地转移 std::unique_ptr 的所有权。
示例代码 ：

#include <memory>
#include <iostream>

class MyClass {
public:
    MyClass() { std::cout << "MyClass created" << std::endl; }
    ~MyClass() { std::cout << "MyClass destroyed" << std::endl; }
};

int main() {
    std::unique_ptr<MyClass> ptr1 = std::make_unique<MyClass>();
    // std::unique_ptr<MyClass> ptr2 = ptr1; // 错误：无法复制
    std::unique_ptr<MyClass> ptr2 = std::move(ptr1); // 合法：转移所有权
    return 0;
}

2. std::shared_ptr

std::shared_ptr 是一种共享所有权的智能指针，意味着多个 std::shared_ptr 可以同时指向同一个对象。对象的生存期由引用计数（reference count）管理，当最后一个 std::shared_ptr 被销毁时，引用计数归零，对象也被销毁。
使用场景 ：
共享所有权：当多个对象需要共享同一资源时，使用 std::shared_ptr。
示例代码 ：

#include <memory>
#include <iostream>

class MyClass {
public:
    MyClass() { std::cout << "MyClass created" << std::endl; }
    ~MyClass() { std::cout << "MyClass destroyed" << std::endl; }
};

int main() {
    std::shared_ptr<MyClass> ptr1 = std::make_shared<MyClass>();
    std::shared_ptr<MyClass> ptr2 = ptr1; // 合法：共享所有权
    std::cout << "Reference count: " << ptr1.use_count() << std::endl; // 引用计数为2
    return 0;
}

3. std::weak_ptr

std::weak_ptr 是一种不控制对象生存期的智能指针，它指向一个由 std::shared_ptr 管理的对象，但不增加引用计数。std::weak_ptr 主要用于解决循环引用问题。
使用场景 ：
弱引用：当需要访问一个由 std::shared_ptr 管理但不应该延长其生存期的对象时，使用 std::weak_ptr。
防止循环引用：在某些数据结构（如双向链表、图）中使用，以避免循环引用导致的内存泄漏。
示例代码 ：

#include <memory>
#include <iostream>

class MyClass {
public:
    MyClass() { std::cout << "MyClass created" << std::endl; }
    ~MyClass() { std::cout << "MyClass destroyed" << std::endl; }
    std::weak_ptr<MyClass> ptr; // 使用 weak_ptr 打破循环引用
};

int main() {
    std::shared_ptr<MyClass> ptr1 = std::make_shared<MyClass>();
    std::shared_ptr<MyClass> ptr2 = std::make_shared<MyClass>();
    
    // 使用 lock() 方法来从 weak_ptr 获取 shared_ptr
    ptr1->ptr = ptr2; // ptr1->ptr 仍然是 weak_ptr，但这里存储的是 ptr2 的 shared_ptr
    ptr2->ptr = ptr1; // ptr2->ptr 也是 weak_ptr，但这里存储的是 ptr1 的 shared_ptr
    
    // 这里需要将 weak_ptr 转换成 shared_ptr，以便可以访问 MyClass 的成员
    if (auto lockedPtr1 = ptr1->ptr.lock()) {
        std::cout << "ptr1's ptr is locked and points to: " << lockedPtr1.get() << std::endl;
    } else {
        std::cout << "ptr1's ptr is expired." << std::endl;
    }
    
    if (auto lockedPtr2 = ptr2->ptr.lock()) {
        std::cout << "ptr2's ptr is locked and points to: " << lockedPtr2.get() << std::endl;
    } else {
        std::cout << "ptr2's ptr is expired." << std::endl;
    }
    
    return 0;
}

输出

MyClass created
MyClass created
ptr1's ptr is locked and points to: 000001E5FCA463B0
ptr2's ptr is locked and points to: 000001E5FCA467D0
MyClass destroyed
MyClass destroyed

循环引用 （写一个错误的例子和正确的例子）

循环引用（cyclic reference）发生在两个或多个对象互相持有对方的引用，导致这些对象无法被正确释放。这种情况通常会导致内存泄漏。使用 std::shared_ptr 管理对象时，容易出现循环引用问题。

循环引用示例 错误的例子

以下是一个简单的循环引用示例：

#include <iostream>
#include <memory>

class B; // 前向声明

class A {
public:
    std::shared_ptr<B> ptrB;
    ~A() { std::cout << "A destroyed" << std::endl; }
};

class B {
public:
    std::shared_ptr<A> ptrA;
    ~B() { std::cout << "B destroyed" << std::endl; }
};

int main() {
    std::shared_ptr<A> a = std::make_shared<A>();
    std::shared_ptr<B> b = std::make_shared<B>();

    a->ptrB = b;
    b->ptrA = a;

    return 0; // 循环引用导致 A 和 B 不会被正确释放
}

创建了两个类 A 和 B，并且它们之间存在循环引用。A 类包含一个指向 B 类的 std::shared_ptr，而 B 类也包含一个指向 A 类的 std::shared_ptr。这会导致循环引用问题，使得 A 和 B 的实例都无法被正确销毁，因为它们互相保持着对彼此的引用。，a 和 b 互相持有对方的 shared_ptr，导致引用计数永远不会归零，从而导致内存泄漏。

循环引用示例 正确的例子

解决循环引用：使用 std::weak_ptr``std::weak_ptr 是一种不增加引用计数的智能指针，可以打破循环引用。以下是修正后的示例：

#include <iostream>
#include <memory>

class B;

class A {
public:
    std::shared_ptr<B> ptrB;
    ~A() { std::cout << "A destroyed" << std::endl; }
};

class B {
public:
    std::weak_ptr<A> ptrA; // 使用 weak_ptr 打破循环引用
    ~B() { std::cout << "B destroyed" << std::endl; }
};

int main() {
    std::shared_ptr<A> a = std::make_shared<A>();
    std::shared_ptr<B> b = std::make_shared<B>();

    a->ptrB = b;
    b->ptrA = a;

    return 0; // A 和 B 会被正确释放
}

输出

A destroyed
B destroyed

对于 std::vector 存储的原始指针，需要手动遍历并调用 delete 释放内存

如果 std::vector 存储的是通过 new 分配的原始指针，必须手动释放这些对象。可以通过循环遍历 vector 来删除所有指针指向的对象，然后清空 vector。

示例

#include <vector>
#include <iostream>

class MyClass {
public:
    MyClass() { std::cout << "MyClass created" << std::endl; }
    ~MyClass() { std::cout << "MyClass destroyed" << std::endl; }
};

int main() {
    std::vector<MyClass*> vec;
    vec.push_back(new MyClass());
    vec.push_back(new MyClass());

    // 释放内存
    for (MyClass* ptr : vec) {
        delete ptr;
    }
    vec.clear();

    return 0;
}

在这个例子中，手动遍历 vector，对每个指针调用 delete 来释放内存，然后清空 vector。std::vector 中装智能指针

对于 std::vector 存储的智能指针，智能指针会自动管理对象的生命周期

如果 std::vector 存储的是智能指针（如 std::unique_ptr 或 std::shared_ptr），智能指针会自动管理对象的生命周期，当 vector 被销毁时，智能指针会自动释放所管理的对象，无需手动释放。

#include <vector>
#include <memory>
#include <iostream>

class MyClass {
public:
    MyClass() { std::cout << "MyClass created" << std::endl; }
    ~MyClass() { std::cout << "MyClass destroyed" << std::endl; }
};

int main() {
    std::vector<std::unique_ptr<MyClass>> vec;
    vec.push_back(std::make_unique<MyClass>());
    vec.push_back(std::make_unique<MyClass>());

    // 当 vec 被销毁时，存储的 unique_ptr 会自动释放 MyClass 对象
    return 0;
}

输出

MyClass created
MyClass created
MyClass destroyed
MyClass destroyed

在这个例子中，std::unique_ptr 会在 vector 作用域结束时自动释放内存。使用 std::shared_ptr

#include <vector>
#include <memory>
#include <iostream>

class MyClass {
public:
    MyClass() { std::cout << "MyClass created" << std::endl; }
    ~MyClass() { std::cout << "MyClass destroyed" << std::endl; }
};

int main() {
    std::vector<std::shared_ptr<MyClass>> vec;
    vec.push_back(std::make_shared<MyClass>());
    vec.push_back(std::make_shared<MyClass>());

    // 当 vec 被销毁时，存储的 shared_ptr 会自动管理 MyClass 对象的生命周期
    return 0;
}

输出

MyClass created
MyClass created
MyClass destroyed
MyClass destroyed

在这个例子中，std::shared_ptr 会在 vector 作用域结束时自动释放内存，只要没有其他 shared_ptr 仍然指向相同的对象。

enable_shared_from_this 和 shared_from_this

enable_shared_from_this 和 shared_from_this 提供了一种安全生成 shared_ptr 的方式
std::enable_shared_from_this 是一个帮助类，允许对象安全地生成指向自身的 std::shared_ptr。
安全地创建 shared_ptr：通过 enable_shared_from_this，可以确保在类成员函数中安全地生成指向当前对象的 shared_ptr，避免多次创建不同的 shared_ptr 导致的问题。

#include <iostream>
#include <memory>

class MyClass : public std::enable_shared_from_this<MyClass> {
public:
    std::shared_ptr<MyClass> getSharedPtr() {
        return shared_from_this();
    }
    ~MyClass() { std::cout << "MyClass destroyed" << std::endl; }
};

int main() {
    std::shared_ptr<MyClass> obj = std::make_shared<MyClass>();
    std::shared_ptr<MyClass> obj2 = obj->getSharedPtr();

    std::cout << "obj use count: " << obj.use_count() << std::endl;  // 输出 2
    std::cout << "obj2 use count: " << obj2.use_count() << std::endl; // 输出 2

    return 0;
}

输出

obj use count: 2
obj2 use count: 2
MyClass destroyed

expired 的作用

expired 是 std::weak_ptr 类中的一个成员函数，用来检查 weak_ptr 指向的对象是否已经被销毁。std::weak_ptr 是一种不拥有对象的指针，它可以观察一个由 std::shared_ptr 管理的对象，但不会影响对象的生命周期。
expired 返回一个布尔值，如果 std::weak_ptr 指向的对象已经被销毁（引用计数为零），它返回 true；否则返回 false。

使用 expired 检查对象是否仍然存在
使用 expired 可以检查 std::weak_ptr 指向的对象是否仍然存在。如果对象已经被销毁，可以避免对一个无效的对象进行操作。

示例代码
以下是一个使用 std::weak_ptr 和 expired 的示例，展示了如何避免循环引用和检查对象的有效性

#include <iostream>
#include <memory>

class MyClass {
public:
    MyClass() { std::cout << "MyClass created" << std::endl; }
    ~MyClass() { std::cout << "MyClass destroyed" << std::endl; }
    std::weak_ptr<MyClass> ptr; // 使用 weak_ptr 打破循环引用
};

int main() {
    {
        // 创建两个 shared_ptr
        auto ptr1 = std::make_shared<MyClass>();
        auto ptr2 = std::make_shared<MyClass>();

        // 互相引用对方的 shared_ptr
        ptr1->ptr = ptr2;
        ptr2->ptr = ptr1;

        // 检查 ptr1 和 ptr2 指向的对象是否仍然存在
        if (ptr1->ptr.expired()) {
            std::cout << "ptr1's ptr is expired." << std::endl;
        } else {
            std::cout << "ptr1's ptr is still valid." << std::endl;
        }

        if (ptr2->ptr.expired()) {
            std::cout << "ptr2's ptr is expired." << std::endl;
        } else {
            std::cout << "ptr2's ptr is still valid." << std::endl;
        }
    } // 这里 ptr1 和 ptr2 超出作用域，被销毁

    // 此时 ptr1 和 ptr2 所指向的对象已经被销毁
    // 所有 MyClass 对象都已经被销毁，析构函数已经被调用

    return 0;
}

std::shared_ptr ：引用计数是线程安全的，但对对象的访问和修改需要额外的同步

当需要多个线程共享对象的所有权，确保对象在有线程使用时不会被销毁，不存在循环引用的风险，多线程里可以用std::shared_ptr。

例子

#include <iostream>
#include <memory>
#include <thread>
#include <vector>

void threadFunction(std::shared_ptr<int> sharedPtr) {
    std::this_thread::sleep_for(std::chrono::milliseconds(100));
    std::cout << "Value: " << *sharedPtr << std::endl;
}

int main() {
    std::shared_ptr<int> sharedPtr = std::make_shared<int>(42);
    
    std::vector<std::thread> threads;
    for (int i = 0; i < 10; ++i) {
        threads.push_back(std::thread(threadFunction, sharedPtr));
    }
    
    for (auto& t : threads) {
        t.join();
    }
    
    return 0;
}

td::unique_ptr：不是线程安全的，不能在多个线程之间共享

std::unique_ptr 不是线程安全的。因为 std::unique_ptr 不能被复制，只能被移动，这意味着同一时间只能有一个线程拥有该指针的所有权。如果需要在多个线程中共享所有权，应该使用 std::shared_ptr。

std::weak_ptr ：调用 lock 方法是线程安全的，但对对象的访问和修改需要额外的同步

当需要避免循环引用，线程只需要观察对象的生命周期，而不需要拥有对象，需要临时访问对象，而不需要延长对象的生命周期，多线程中用std::weak_ptr。

#include <iostream>
#include <memory>
#include <thread>
#include <vector>

void threadFunction(std::weak_ptr<int> weakPtr) {
    std::this_thread::sleep_for(std::chrono::milliseconds(100));
    if (auto sharedPtr = weakPtr.lock()) {
        std::cout << "Value: " << *sharedPtr << std::endl;
    } else {
        std::cout << "Object has been destroyed." << std::endl;
    }
}

int main() {
    std::shared_ptr<int> sharedPtr = std::make_shared<int>(42);
    std::weak_ptr<int> weakPtr = sharedPtr;

    std::vector<std::thread> threads;
    for (int i = 0; i < 10; ++i) {
        threads.push_back(std::thread(threadFunction, weakPtr));
    }

    for (auto& t : threads) {
        t.join();
    }

    sharedPtr.reset(); // 销毁对象

    return 0;
}