unique_ptr、memcpy等一些实现

面试让我手撕unique_ptr，被吓怕了，记录一些偏底层的实现或者一些可能让手撕的比较偏的函数

1. unique_ptr实现
2. memcpy实现—注意地址重叠
3. 重写构造函数与赋值函数—有指针类型时，防止重复释放内存
4. 可变参数模板
5. i++,++i
6. shared_ptr死锁情况
7. 单例模式
8. 工厂模式(简单工厂模式、工厂模式、抽象工厂模式)
9. 环形队列(二倍扩容)
10. shared_ptr实现
11. strcpy实现

unique_ptr实现

#include 
using namespace std;
template<class T>
class Unique_ptr
{
   
private:
    T* ptr=NULL;
public:
    Unique_ptr(Unique_ptr& u) = delete;
    Unique_ptr& operator=(Unique_ptr& u) = delete;
    Unique_ptr(T* p)
    {
   
        ptr = p;
        cout << "构造" << endl;
    }
    Unique_ptr()
    {
   
    }
    ~Unique_ptr()
    {
   
        if (ptr)
        {
   
            delete ptr;
            ptr = NULL;
            cout << "析构" << endl;
        }
    }
    Unique_ptr(Unique_ptr&& p)
    {
   
        ptr = p.ptr;
        p.ptr = NULL;
    }
    Unique_ptr& operator=(Unique_ptr&& p)
    {
   
        if(this!=&p){
   
            ptr = p.ptr;
            p.ptr = NULL;
        }
        return *this;
    }
    T* operator->()
    {
   
        return ptr;
    }
    T& operator*()
    {
   
        if (ptr)
        {
   
            return *ptr;
        }
        T a = -1;
        return a;
    }
	
};
int main()
{
   
    int* a = new int(10);
    Unique_ptr<int> p(a);
    cout << *p << endl;
    Unique_ptr<int> p1=move(p);
    cout << *p1 << endl;
    cout << *p << endl; 
}

memcpy实现—注意地址重叠

#include 
using namespace std;
template <class T>
T* my_memcpy(T* dst, T* src, int size_s)
{
   
    if (sizeof(dst) < size_s)
    {
   
        return NULL;
    }
    if (dst == NULL || src == NULL)
    {
   
        return NULL;
    }
    if (src < dst && (src + size_s > dst))
    {
   
        T* d = dst + size_s - 1;
        T* s = src + size_s - 1;
        while (size_s--)
        {
   
            *d = *s;
            d--;
            s--;
        }
    }
    else
    {
   
        T* d = dst;
        T* s = src;
        while (size_s--)
        {
   
            *d = *s;
            d++;
            s++;
        }
    }
    return dst;
}
int main()
{
   
    char buf[5] = "abcd";
    char buf1[4];
   // memcpy(buf + 2, buf, 5);
    cout << sizeof(buf1);
    char* res=my_memcpy<char>(buf1, buf, 5);
    if (res == NULL)
    {
   
        cout << 0;
        return 0;
    }
    for (int i = 0; i < strlen(res); i++)
    {
   
        cout << res[i];
    }

}

重写构造函数与赋值函数—有指针类型时，防止重复释放内存

#include 
using namespace std;
class base
{
   
private:
    int id;
    int* ptr;
public:
    base(int a, int* d)
    {
   
        id = a;
        ptr = new int;
        if (d)
        {
   
            *ptr = *d;
        }
    }
    ~base()
    {
   
        if (ptr)
        {
   
            delete ptr;
            ptr = NULL;
            cout << "析构" << endl;
        }  
    }
    base(const base& b)
    {
   
        id = b.id;
        ptr = new int;