C++高级编程（1）-- 智能指针的高级用法

智能指针的高级用法

在C++中，智能指针是一种对象，它可以像常规指针一样使用，但它有一个重要的额外特性：它负责自动释放它所指向的对象。这个特性使得内存管理变得更加简单和安全，减少了内存泄漏和悬空指针的风险。

C++标准库提供了几种类型的智能指针，包括std::unique_ptr、std::shared_ptr和std::weak_ptr。这些智能指针各有各的用途和特点，但它们共同的目标是帮助开发者更好地管理内存。

unique_ptr

std::unique_ptr是一种独占所有权的智能指针，也就是说，同一时间只能有一个unique_ptr指向给定的对象。当unique_ptr被销毁（例如，离开作用域）时，它会自动删除它所指向的对象。

这是一个unique_ptr的基本用法示例：

#include <memory>

void f() {
    std::unique_ptr<int> p(new int(42));
    // 在这个函数结束时，p会被销毁，并自动删除它所指向的int对象
}

高级用法

std::unique_ptr还可以用于实现移动语义，这可以提高代码的性能。例如：

std::unique_ptr<int> create() {
    return std::unique_ptr<int>(new int(42));
}

void g() {
    std::unique_ptr<int> p = create(); // 使用移动语义，避免了不必要的拷贝
}

shared_ptr

std::shared_ptr是一种共享所有权的智能指针，也就是说，可以有多个shared_ptr指向同一个对象。只有当最后一个shared_ptr被销毁时，它所指向的对象才会被删除。

这是一个shared_ptr的基本用法示例：

#include <memory>

void f() {
    std::shared_ptr<int> p1(new int(42));
    {
        std::shared_ptr<int> p2 = p1; // p1和p2都指向同一个对象
        // 在这个内部作用域结束时，p2会被销毁，但因为它并不是最后一个指向该对象的shared_ptr，所以该对象不会被删除
    }
    // 在这个函数结束时，p1会被销毁，因为它是最后一个指向该对象的shared_ptr，所以该对象会被删除
}

高级用法

std::shared_ptr还可以用于实现线程安全的单例模式，这可以提高代码的安全性。例如：

#include <memory>
#include <mutex>

class Singleton {
public:
    static std::shared_ptr<Singleton> getInstance() {
        std::call_once(initFlag, [] {
            instance.reset(new Singleton);
        });
        return instance;
    }
private:
    Singleton() {}
    Singleton(const Singleton&) = delete;
    Singleton& operator=(const Singleton&) = delete;
    static std::shared_ptr<Singleton> instance;
    static std::once_flag initFlag;
};

std::shared_ptr<Singleton> Singleton::instance;
std::once_flag Singleton::initFlag;

weak_ptr

std::weak_ptr是一种不拥有所有权的智能指针，它可以用来避免shared_ptr之间的循环引用问题。一个weak_ptr不会增加它所指向对象的引用计数，因此，即使有weak_ptr指向一个对象，该对象也可能会被删除。

这是一个weak_ptr的基本用法示例：

#include <memory>

struct S {
    std::shared_ptr<S> p;
};

void f() {
    std::shared_ptr<S> p1(new S);
    p1->p = p1; // p1现在指向自己，形成了循环引用
    std::weak_ptr<S> wp = p1; // wp是一个weak_ptr，不会增加p1的引用计数
    if (auto p2 = wp.lock()) { // lock()尝试获取一个shared_ptr，如果成功，说明对象还存在
        // 在这里可以使用p2
    }
}

高级用法

std::weak_ptr还可以用于实现观察者模式，这可以提高代码的灵活性。例如：

#include <memory>
#include <vector>
#include <algorithm>

class Observer {
public:
    virtual void update() = 0;
};

class Subject {
public:
    void addObserver(std::weak_ptr<Observer> observer) {
        observers.push_back(observer);
    }
    void notify() {
        for (auto it = observers.begin(); it != observers.end(); /* empty */) {
            if (auto observer = it->lock()) {
                observer->update();
                ++it;
            } else {
                it = observers.erase(it);
            }
        }
    }
private:
    std::vector<std::weak_ptr<Observer>> observers;
};

持续更新中…