手撕代码

1、阻塞队列/线程安全队列

实现：

注意问题：

　　1、防止虚假唤醒的lambda表达式需要传入this，也就是调用变量

　　2、lambda表达式的函数体不可以使用自己写的判断队列满或者空函数

template <typename T>
class block_queue
{
public:
    block_queue(int max_size = 1000)
    {
        if (max_size <= 0)
        {
            exit(-1);
        }

        m_max_size = max_size;
        m_size = 0;
        m_array = new T[m_max_size];
        m_front = -1;;
        m_back = -1;
    }
    block_queue(const block_queue&) = delete;

    ~block_queue()
    {
        std::unique_lock<std::mutex> ulk(m_mutex);
        if (m_array != NULL)
            delete[] m_array;
    }

    /*
        往队列添加元素，需要将所有使用队列的线程先唤醒
        当有元素push进队列,相当于生产者生产了一个元素
        若当前没有线程等待条件变量,则唤醒无意义
    */
    bool push(const T &item)
    {
        std::unique_lock<std::mutex> ulk(m_mutex);

        /*
        while (m_size >= m_max_size)
            m_cond.wait(ulk);
        */

        m_cond.wait(ulk, [this]() {
            return m_size < m_max_size;
        });

        //将新增数据放在循环数组的对应位置
        m_back = (m_back + 1) % m_max_size;
        m_array[m_back] = item;
        m_size++;

        m_cond.notify_all();
        return true;
    }
    //pop时,如果当前队列没有元素,将会等待条件变量
    bool pop(T &item)
    {
        std::unique_lock<std::mutex> ulk(m_mutex);

        /*
        //多个消费者的时候，这里要是用while而不是if
        while (m_size <= 0)
            m_cond.wait(guard);
        */
        m_cond.wait(ulk, [this]() {
            return m_size > 0;
        });

        //取出队列首的元素，这里需要理解一下，使用循环数组模拟的队列
        m_front = (m_front + 1) % m_max_size;
        item = m_array[m_front];
        m_size--;
        m_cond.notify_all();
        return true;
    }

    //返回队首元素
    bool front(T &value)
    {
        std::unique_lock<std::mutex> ulk(m_mutex);
        if (0 == m_size)
        {
            //ulk.unlock();
            return false;
        }
        value = m_array[m_front];
        m_mutex.unlock();
        return true;
    }

    //返回队尾元素
    bool back(T &value)
    {
        std::unique_lock<std::mutex> ulk(m_mutex);
        if (0 == m_size)
        {
            //ulk.unlock();
            return false;
        }
        value = m_array[m_back];
        return true;
    }


    int size()
    {
        int tmp = 0;
        std::unique_lock<std::mutex> ulk(m_mutex);
        tmp = m_size;
        return tmp;
    }

    int max_size()
    {
        int tmp = 0;
        std::unique_lock<std::mutex> ulk(m_mutex);
        tmp = m_max_size;
        return tmp;
    }

    //判断队列是否满了
    bool full()
    {
        std::unique_lock<std::mutex> ulk(m_mutex);
        if (m_size >= m_max_size)
        {
            return true;
        }
        return false;
    }
    //判断队列是否为空
    bool empty()
    {
        std::unique_lock<std::mutex> ulk(m_mutex);
        if (0 == m_size)
        {
            return true;
        }
        return false;
    }

private:
    std::mutex m_mutex;
    std::condition_variable m_cond;

    int m_max_size;
    int m_size;
    T* m_array;
    int m_front;
    int m_back;
};

 2、unique_ptr智能指针

　　C++11中又引入了unique_ptr，他的实现思路非常简单粗暴，就是防拷贝，既然多个智能指针指向同一资源会导致问题，那就干脆不让你这样做，这样问题自然也就解决了。C++11中也是非常推荐使用这种智能指针，因为其比起shared_ptr和auto_ptr来说较为稳定，不会导致严重的错误但是其也存在缺陷，就是在需要拷贝的场景下他没有办法使用。

实现：

　　1、禁止拷贝构造

　　2、进制复制构造

　　3、可以实现移动语义

template<typename T>
class My_unique_ptr
{
private:
    T* _ptr;
public:
    My_unique_ptr(const T* ptr) : _ptr(ptr) {}
    My_unique_ptr(const My_unique_ptr<T>&) = delete;
    My_unique_ptr& operator=(const My_unique_ptr<T>&) = delete;
    ~My_unique_ptr()
    {
        if (_ptr)
        {
            delete _ptr;
            _ptr = nullptr;
        }
    }
    T& operator*()
    {
        return *_ptr;
    }
    T* operator->()
    {
        return _ptr;
    }
};

3、实现shared_ptr智能指针

　　为了弥补unique_ptr不能拷贝的缺陷，C++11中还引入了shared_ptr，他的实现思路是引用计数，通过计数的方式来实现多个智能指针共同管理一个资源。shared_ptr在其内部，给每个资源都维护了着一份计数，用来记录该份资源被几个对象共享。在对象被销毁时(也就是析构函数调用)，就说明自己不使用该资源了，对象的引用计数减一。如果引用计数是0，就说明自己是最后一个使用该资源的对象，必须释放该资源；如果不是0，就说明除了自己还有其他对象在使用该份资源，不能释放该资源，否则其他对象就成野指针了。

　　相较于unique_ptr，它弥补了不能拷贝的缺陷，但是因为需要保证多线程并发时的线程安全问题，所以对于计数操作要进行加锁，所以导致其效率相对来说会低一些，并且还存在循环引用的问题，所以大部分情况下如果不需要进行拷贝，都会使用unique_ptr，需要拷贝时才使用shared_ptr.

实现：

　　1、引用计数实现

　　2、独特地析构函数

　　3、允许拷贝构造

　　4、允许复制构造（注意：需要先释放掉原来所指向地对象）

template<typename T>
class mysharedptr {
private:
    T* _ptr;
    int* _pcount;
    std::mutex* _pmtx;
    //加锁保证线程安全
    void add_ref_count() {
        _pmtx->lock();
        ++(*_pcount);
        _pmtx->unlock();
    }
    void release() {
        bool flag = false;
        _pmtx->lock();
        if (--(*_pcount) == 0) {
            if (_ptr) {
                delete _ptr;
                _ptr = nullptr;
            }
            delete _pcount;
            _pcount = nullptr;
            flag = true;
        }
        _pmtx->unlock();
        if (flag) {
            delete _pmtx;
            _pmtx = nullptr;
        }
    }

public:
    mysharedptr(T* ptr) : _ptr(ptr), _pcount(new int(1)), _pmtx(new std::mutex) {}
    mysharedptr(mysharedptr<T>& sp) : _ptr(sp._ptr), _pcount(sp._pcount), _pmtx(sp._pmtx){
        add_ref_count();
    }
    mysharedptr<T>& operator=(mysharedptr<T>& sp) {
        if (this != &sp ) {
            release();        //自己原来所指向的对象的引用计数减1
            _ptr = sp._ptr;
            _pcount = sp._pcount;
            _pmtx = sp._pmtx;

            add_ref_count();
        }
        return *this;
    }
    ~mysharedptr() {
        release();
    }

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

    T* get() const {
        return _ptr;
    }
    size_t use_count() const {
        return *_pcount;
    }
};

 四、数字字符串相加（lc415）

string addStrings(string num1, string num2) {
    int len1 = num1.size(), len2 = num2.size();
    int len = max(len1, len2);
    vector<int> reg(len, 0);
    int i1 = len1 - 1, i2 = len2 - 1, index = len - 1, pre = 0;
    string ans;
    while (i1 >= 0 || i2 >= 0 || pre != 0)
    {
        int x = i1 >= 0 ? num1[i1] - '0' : 0;
        int y = i2 >= 0 ? num2[i2] - '0' : 0;
        int cur = x + y + pre;
        ans.push_back('0' + cur % 10);
        pre = cur / 10;
        i1--;
        i2--;
    }
    reverse(ans.begin(), ans.end());
    return ans;
}