C++高仿智能指针（共享指针）

smart_ptr

序言

• 基于C++11的高仿shared_ptr智能指针，这是作者第一个项目，使用了中文文档，如有不规范的地方，还请读者海涵。
• 该项目实现了shared_ptr的相应方法，完成这个小项目可以对C++的学习有更进一步的复习，今后也会更新STL标准库的实现，以及对其的维护，敬请期待；如有建议欢迎评论。

实验环境

• Windows环境

• gcc version 8.1.0 (x86_64-posix-seh-rev0, Built by MinGW-W64 project)

• vscode C++

如何使用

• 创建指针

void test() {
    smart_ptr<int> p = make_smart<int>(15);
    cout << *p << "\n"; //15

    smart_ptr<std::string> p2(new std::string("aaaa"));
    cout << *p2 << "\n"; //aaaa

    smart_ptr<int> p3(new int[5]{42,1,2,5,0}, [](int* p) ->void {
        delete[] p;
        p = nullptr;
    });
}

• 类似make_shared<T>()方法

template<typename T, typename... Args>
smart_ptr<T> make_smart(Args&&... args) {
    //找到T类型的(移动、拷贝、默认)构造函数，使用对应的构造函数创建对象
    smart_ptr<T> sp(new T(std::forward<Args>(args)...));
    return sp;
}

代码

/** @file    smart_pointer.hpp
 *  @author  爱模板元的小白(csdn)
 *  @date    2023/06/26 19:42:05
 *  @remark  Similar to shared_ptr
 *  @note
 */ 

#ifndef SMART_POINTER_H
#define SMART_POINTER_H
#include<functional>

template<class T>
class smart_ptr {
public:
    /*
        class controller
    */
    smart_ptr() : _use_count(nullptr), _resourse(nullptr) {}

    explicit smart_ptr(T* val_ptr) : _use_count(new size_t(1)), _resourse(val_ptr) {}

    explicit smart_ptr(T* val_ptr, std::function<void(T*)> del) : _use_count(new size_t(1)),
                                                        _resourse(val_ptr),
                                                        _deleter(del) {}

    smart_ptr(size_t* uc, T* val_ptr, std::function<void(T*)> del) : _use_count(uc),
                                                                    _resourse(val_ptr),
                                                                    _deleter(del) {}

    /*
        copy member
    */
    smart_ptr(const smart_ptr& rhs) : _use_count(nullptr),
                                    _resourse(nullptr) {
                                    //
        ++(*rhs._use_count);
        smart_ptr<T> temp(rhs._use_count, rhs._resourse, rhs._deleter);
        swap(temp);
    }

    smart_ptr& operator=(const smart_ptr& rhs) {
        if(&rhs != this) {
            smart_ptr<T> temp(rhs);
            swap(temp);
        }
        return *this;
    }

    /*
        move member
    */
    smart_ptr(smart_ptr&& rhs) noexcept : _use_count(nullptr),
                                _resourse(nullptr) {
                                    //
        swap(rhs);
        rhs._use_count = nullptr;
        rhs._resourse = nullptr;
    }

    ~smart_ptr() {
        free();
    }

public:
    /*
        interface function
    */
    T& 
    operator*() const noexcept {
        return *_resourse;
    }

    T* 
    operator->() const noexcept {
        return &this->operator*();
    }

    explicit operator bool() const noexcept { //类对象当成bool类型使用
        return _resourse != nullptr;
    }
    
    size_t 
    use_count() const noexcept {
        return _use_count ? *_use_count : 0;
    }
    
    T* 
    get() const noexcept {
        return _resourse;
    }

    void 
    reset() noexcept {
        smart_ptr().swap(*this);
    }

    void 
    reset(T* p) noexcept {
        if(p || p != _resourse)
            smart_ptr(p).swap(*this);
    }
    
    void 
    reset(T* p, std::function<void(T*)> del) noexcept {
        if(p || p != _resourse)
            smart_ptr(p, del).swap(*this);
    }

    void 
    swap(smart_ptr<T>& rhs) {
        using std::swap;
        std::swap(_use_count, rhs._use_count);
        std::swap(_resourse, rhs._resourse);
        std::swap(_deleter, rhs._deleter);
    }

    bool
    unique() const noexcept {
        return use_count() == 1;
    }

private:
    /*
        utility function
    */
    void 
    free() {
        if(_use_count) {
            if(--(*_use_count) == 0) {
                if(_resourse) {
                    _deleter(_resourse);
                    _resourse = nullptr;
                }
                delete _use_count;
                _use_count = nullptr;
            }
        }
    }

private:
    /*
        class member
    */
    std::size_t* _use_count = nullptr;
    T* _resourse;
    static std::function<void(T*)> _default_deleter;
    std::function<void(T*)> _deleter = _default_deleter;
};

template<class T>
std::function<void(T*)> 
smart_ptr<T>::_default_deleter = [](T* p) {delete p; p = nullptr;};

template<typename T, typename... Args>
smart_ptr<T> make_smart(Args&&... args) {
    //找到T类型的(移动、拷贝、默认)构造函数，使用对应的构造函数创建对象
    smart_ptr<T> sp(new T(std::forward<Args>(args)...));
    return sp;
}

#endif //SMART_POINTER_H