_M_ konstruieren null nicht gültig Fehler, wenn Sie versuchen zu implementieren multi-threaded-Warteschlange

Ich versuche zur Implementierung einer priority-queue mit Verwendung einer einfachen linearen Ansatz, wie in Kunst von Multiprozessor-Programmierung. Ich bin neu in c++ und haben Schwierigkeiten, die Fehlersuche.

Habe ich umgesetzt zwei template-Klassen und bin zum testen mit einem einfachen test-Methode. Wie ich bin nicht in der Lage zu pin zeigen Sie die Fehler, ich bin einfügen alle drei Klassen unterhalb der Referenz.

Ich weiß, dass _M_ construct null not valid kommt beim Versuch, erstellen Sie eine Zeichenfolge mit nullptr, bin mir aber nicht sicher, wo ich bin, das zu tun.

Den drei Klassen erstellt werden, sind unten angegeben:

bin.h

#include <mutex>
#include <deque>
#include <memory>
#include <iostream>
using namespace std;

namespace priority
{
    template<typename T>
    class Bin
    {
    private:
        std::deque<T> v;
        std::mutex m;
    public:
        Bin() {
        }

        Bin(const Bin &o) {

        }

        const Bin &operator=(const Bin &other) {
            return *this;
        }

        void put(T item) {
            std::lock_guard<std::mutex> lock(m);
            v.push_back(item);
        }

        T *get() {
            std::lock_guard<std::mutex> lock(m);
            if (v.size() == 0) {
                return nullptr;
            }
            else {
                T val = v.front();
                T *ptr_val = &(val);
                v.pop_front();
                return ptr_val;
            }
        }

        bool isEmpty() {
            std::lock_guard<std::mutex> lock(m);
            return v.size() == 0;
        }

    };  
}

SimpleLinear.h

#include <mutex>
#include <vector>
#include <memory>
#include "Bin.h"

namespace priority
{   
    template<typename T>
    class SimpleLinear
    {
    private:
        int range;
        std::vector<Bin<T>> pqueue;
    public:
        SimpleLinear(int range){
            this->range = range;

            for (int i = 0; i < range; i++)
            {
                pqueue.push_back(Bin<T>());
            }

        }

        void add(T item, int key) {
            pqueue[key].put(item);
        }

        T removeMin() {
            for (int i = 0; i < range; i++)
            {
                T *item = pqueue[i].get();
                if (item != nullptr) {
                    return *item;
                }
            }
            return nullptr;
        }

    };
}

test.cpp

#include <iostream>
#include <vector>
#include <thread>
#include <algorithm>
#include "SimpleLinear.h"
using namespace std;
using namespace priority;

void te(SimpleLinear<string> s, int thread_id) {

    s.add("sundar"+to_string(thread_id), thread_id);
    s.add("akshaya"+to_string(thread_id), 3);
    s.add("anirudh"+to_string(thread_id), 1);
    s.add("aaditya"+to_string(thread_id), 5);
    cout << s.removeMin() << endl;
    cout << s.removeMin() << endl;
    cout << s.removeMin() << endl;

}


int main(int argc, char const *argv[])
{   

    SimpleLinear<string> s(100);
    std::vector<std::thread> v;

    for (int i = 0; i < 100; i++)
    {   
        //if (i % 2 == 0)
            v.push_back(thread(te, std::ref(s), i));
        //else
            //v.push_back(thread(t, std::ref(s), i));


    }
    for_each(v.begin(), v.end(), std::mem_fn(&std::thread::join));
    return 0;
}

Ich bin immer der Fehler:

terminate called after throwing an instance of 'std::logic_error'
  what():  basic_string::_M_construct null not valid
terminate called recursively
terminate called recursively
terminate called recursively
Aborted (core dumped)