【分布式锁】基于Redisson的分布式锁实现-CFANZ编程社区

作者主页： 作者主页

本篇博客专栏：C++

创作时间：2024年8月20日

一，什么是智能指针

c++中用的最多的是下面三种智能指针

二，共享的智能指针`shared_ptr`

首先了解一下基本概念，再看代码，会学的很快

1. shared_ptr的初始化

2.获取原始指针

3. 指定删除器

下面我们来看一下代码如何实现：

#pragma once
#include <iostream>
#include <functional>


namespace zy
{
    template<class T>
    class shared_ptr
    {
    public:
        shared_ptr(T* ptr = nullptr) 
            : _ptr(ptr)
            , _pcount(ptr ? new int(1) : nullptr)
        {
            std::cout << "shared_ptr(T* ptr)" << std::endl;
        }

        template<class D>
        shared_ptr(T* ptr = nullptr,D del)
            : _ptr(ptr)
            , _pcount(ptr ? new int(1) : nullptr)
            , _del(del)
        {}

        shared_ptr(const shared_ptr& sp) 
            : _ptr(sp._ptr)
            , _pcount(sp._pcount)
        {
            ++(*_pcount);
            std::cout << "Copy constructor" << std::endl;
        }

        shared_ptr& operator=(const shared_ptr& sp)
        {
            if (this != &sp)
            {
                // 释放当前对象管理的资源（如果有）
                this->Realease();

                _ptr = sp._ptr;
                _pcount = sp._pcount;
                ++(*_pcount);
            }
            return *this;
        }

        ~shared_ptr()
        {
            Realease();
        }

        void Realease()
        {
            if (_pcount && --(*_pcount) == 0)
            {
                //delete _ptr;
                _del(_ptr);

                delete _pcount;
                _ptr = nullptr;
                _pcount = nullptr;
            }
        }

        T* get()
        {
            return _ptr;
        }

        int use_count()
        {
            return _pcount ? *_pcount : 0;
        }

        T& operator*() { return *_ptr; }
        T* operator->() { return _ptr; }

    private:
        T* _ptr;
        int* _pcount;

        fuction<void(T* ptr)>_del = [](T* ptr) {delete ptr};
    };
}

三，独占的智能指针unique_ptr

1. 初始化

2. 删除器

#pragma once
#include <iostream>

template <typename T>
class unique_ptr {
public:
    // 构造函数，接受一个原始指针并接管其所有权
    unique_ptr(T* ptr = nullptr) 
     : ptr_(ptr) 
    {}

    // 移动构造函数，转移所有权
    unique_ptr(unique_ptr&& other) noexcept : ptr_(other.ptr_) {
        other.ptr_ = nullptr;
    }

    // 移动赋值运算符，转移所有权
    unique_ptr& operator=(unique_ptr&& other) noexcept {
        if (this!= &other) {
            reset();
            ptr_ = other.ptr_;
            other.ptr_ = nullptr;
        }
        return *this;
    }

    // 析构函数，释放所管理的资源
    ~unique_ptr() {
        reset();
    }

    // 解引用操作符
    T& operator*() const {
        return *ptr_;
    }

    // 箭头操作符
    T* operator->() const {
        return ptr_;
    }

    // 获取原始指针
    T* get() const {
        return ptr_;
    }

    // 释放所管理的资源并将指针置为 nullptr
    void reset(T* ptr = nullptr) {
        if (ptr_) {
            delete ptr_;
        }
        ptr_ = ptr;
    }

private:
    T* ptr_;
};

四，弱引用的智能指针weak_ptr

1 初始化

#include <iostream>
#include <memory>
using namespace std;
 
int main() 
{
    shared_ptr<int> sp(new int);
 
    weak_ptr<int> wp1;
    weak_ptr<int> wp2(wp1);
    weak_ptr<int> wp3(sp);
    weak_ptr<int> wp4;
    wp4 = sp;
    weak_ptr<int> wp5;
    wp5 = wp3;
    
    return 0;
}