C++标准库中的智能指针用法和设计模式解析？

智能指针的简介

智能指针是C++标准库中用于自动化内存管理的工具，旨在防止内存泄漏和提升代码的可维护性。传统的直接使用裸指针进行内存管理，很容易出现内存泄漏和悬挂指针等问题，而智能指针通过RAII（Resource Acquisition Is Initialization）技术，在对象生命周期结束时自动释放内存，从而提高了安全性和效率。

智能指针的种类

std::unique_ptr

std::unique_ptr是独占所有权的智能指针，意味着在任何时间点都只有一个指针可以拥有对象。当std::unique_ptr对象被销毁或者重新赋值时，所指向的对象也会被释放。

#include 
#include 
class MyClass {
public:
    MyClass() { std::cout << "MyClass Constructor\n"; }
    ~MyClass() { std::cout << "MyClass Destructor\n"; }
};
int main() {
    std::unique_ptr ptr1(new MyClass());
    // Transfer ownership
    std::unique_ptr ptr2 = std::move(ptr1);
    // ptr1 is now nullptr
    if (!ptr1) {
        std::cout << "ptr1 is nullptr\n";
    }
    return 0;
}

std::shared_ptr

std::shared_ptr是共享所有权的智能指针，允许多个shared_ptr指向同一个对象。当最后一个shared_ptr离开作用域或显式释放时，所指向的对象才会被销毁。这种机制通过引用计数来实现。

#include 
#include 
class MyClass {
public:
    MyClass() { std::cout << "MyClass Constructor\n"; }
    ~MyClass() { std::cout << "MyClass Destructor\n"; }
};
int main() {
    std::shared_ptr ptr1 = std::make_shared();
    std::shared_ptr ptr2 = ptr1; // Shared ownership
    std::cout << "Reference count: " << ptr1.use_count() << "\n";
    
    // ptr1 and ptr2 go out of scope, MyClass object is destroyed.
    return 0;
}

std::weak_ptr

std::weak_ptr是一种不增加引用计数的智能指针。它通常与std::shared_ptr配合使用，解决循环引用的问题。std::weak_ptr不会直接管理对象的生命周期，但可以安全地观察和转换成std::shared_ptr。

#include 
#include 
class MyClass {
public:
    MyClass() { std::cout << "MyClass Constructor\n"; }
    ~MyClass() { std::cout << "MyClass Destructor\n"; }
};
int main() {
    std::shared_ptr sp = std::make_shared();
    std::weak_ptr wp = sp; // Doesn't increase reference count
    
    if (std::shared_ptr locked = wp.lock()) {
        std::cout << "Managed object is still alive.\n";
    } else {
        std::cout << "Managed object is already destroyed.\n";
    }
    
    // sp goes out of scope, MyClass object is destroyed.
    return 0;
}

设计模式中的智能指针

单例模式

单例模式确保一个类只有一个实例，并提供一个全局访问点。使用std::unique_ptr可以简化单例模式的实现，因为unique_ptr自动管理单例对象的生命周期。

#include 
#include 
class Singleton {
public:
    static Singleton& getInstance() {
        static std::unique_ptr instance(new Singleton());
        return *instance;
    }
    
    void doSomething() {
        std::cout << "Doing something with Singleton\n";
    }
private:
    Singleton() { }
    ~Singleton() { }
    
    // Delete copy constructor and assignment operator
    Singleton(const Singleton&) = delete;
    Singleton& operator=(const Singleton&) = delete;
};
int main() {
    Singleton::getInstance().doSomething();
    return 0;
}

观察者模式

观察者模式定义了一种一对多的依赖关系，让多个观察者对象同一个主题对象变化时得到通知进行更新。std::weak_ptr可以防止循环引用，确保观察者不会阻止主题对象释放。

#include 
#include 
#include 
class Observer {
public:
    virtual void update() = 0;
    virtual ~Observer() = default;
};
class ConcreteObserver : public Observer {
public:
    void update() override {
        std::cout << "ConcreteObserver has been notified.\n";
    }
};
class Subject {
public:
    void addObserver(std::shared_ptr obs) {
        observers.push_back(obs);
    }
    void notifyObservers() {
        for (auto wp : observers) {
            if (auto sp = wp.lock()) {
                sp->update();
            }
        }
    }
private:
    std::vector> observers;
};
int main() {
    std::shared_ptr subject = std::make_shared();
    std::shared_ptr observer1 = std::make_shared();
    std::shared_ptr observer2 = std::make_shared();
    
    subject->addObserver(observer1);
    subject->addObserver(observer2);
    
    subject->notifyObservers();
    
    return 0;
}

通过结合使用C++标准库中的智能指针，其中unique_ptr、shared_ptr和weak_ptr，可以在实现常见设计模式时大大简化代码复杂性，增加代码的安全性和可维护性。