手写智能指针SharedPtr

template <T>
class SharedPtr {
private:
    size_t* m_counter_;
    T* m_ptr_;
public:
    // 构造函数
    SharedPtr():m_counter_(new size_t),m_ptr_(new T){
        m_counter_ = 1;
    }
    // 构造函数
    SharedPtr(T* ptr)::m_counter_(new size_t),m_ptr_(ptr){
        m_counter_ = 1;
    }
    // 析构函数
    ~SharedPtr(){
        --(*m_counter_);
        if (*m_counter_ == 0) {
            delete m_counter_;
            delete m_ptr_;
            m_ptr_ = nullptr;
            m_counter_ = nullptr;
        }
    }
    // 拷贝构造函数
    SharedPtr(const SharedPtr& ptr) {
        m_counter_ = ptr.m_counter_;
        m_ptr_ = ptr.m_ptr_;
        ++(*m_counter_);
    }
    // 拷贝赋值函数
    void operator=(const SharedPtr& ptr) {
        SharedPtr(std::move(ptr));
    }
    // 移动构造函数
    SharedPtr(SharedPtr&& ptr) {
        m_counter_ = ptr.m_counter_;
        m_ptr_ = ptr.m_ptr_;
        ++(*m_counter_);
    }
    // 移动赋值函数
    void operator=(SharedPtr&& ptr) {
        SharedPtr(std::move(ptr));
    }
    // 解引用
    T& operator*() {
        return *m_ptr_;
    }
    // 箭头运算
    T* operator->(){
        return m_ptr_;
    }
    // 重载bool操作符
    bool operator ==(){
        return m_ptr_ == nullptr;
    }
    // get函数
    T* get(){
        return m_ptr_;
    }
    // use_count
    size_t use_count(){
        return *m_count_;
    }
    bool unique(){
        return *m_count_ == 1;
    }
    void swap(SharedPtr& ptr) {
        std::swap(*this, ptr);
    }
    
    
}

手写memcpy()函数

void* memcpy(void* dest, void* src, size_t num){
    char* p1 = (char*) dest;
    char* p2 = (char*) src;
    // 如果p1在前
    if (p1 < p2) {
        for(size_t i = 0; i < num; i++) {
            *(p1++) = *(p2++);
        }
    }
    else {
        p1 += num - 1;
        p2 += num - 1;
        for (size_t i =0; i < num; i++) {
            *(p1--) = *(p2--);
        }
    }
}