basic_string :: _ M_constructor null недействительно

Question

я делал свой график для своей домашней работы в университете, и когда я искал маршрут моего графика, иногда он давал мне basic_string :: _ M_constructor значение NULL недействительно, но иногда нет.Я попытался отладить мое приложение, но работает нормально с отладкой.Так что я не знаю, почему это происходит.Все мои T-объекты являются строками.Спасибо за Ваше внимание.Вот мой поиск функции и мой маршрут поиска функции.

 template<class T>
 void Graph<T>::search()
    {
    T actual;
    T origin;
    T destiny;
    Couples<T> couples;
    Stack<Couples<T>> myStack;
    Stack<T> stack;
    Queue<T> myQueue;
    List<T> myList;
    cout<<"Origin:";
    cin>>origin;
    cout<<"Destiny:";
    cin>>destiny;

    if(findVertex(origin)!=-1 and findVertex(destiny)!=-1){
        myQueue.enqueue(origin);
        while (!myQueue.isEmpty()) {
            actual=myQueue.dequeue();
            if(myList.search(actual)==-1){
                if(actual==destiny){
                     showRute(myStack,destiny);
                     break;
                }
                if(myList.search(actual)==-1){
                    myList.insert(actual);

                }
                int pos=findVertex(actual);
                for (int i = 0; i < 10; ++i) {
                    if(edge[pos][i].exists){
                        if(myList.search(vertex[i].name)==-1){
                            myQueue.enqueue(vertex[i].name);
                            couples.setActual(actual);
                            couples.setDestiny(vertex[i].name);
                            myStack.push(couples);
                        }


                    }
                }


                if(myQueue.isEmpty()){
                    cout<<"No path "<<endl;
                }
            }

        }

        myList.deleteList();
        stack.deleteStack();
        cout<<endl;
        stack.push(origin);
        while (!stack.isEmpty()) {
            actual=stack.pop();
            if(actual==destiny){
                 showRute(myStack,destiny);
                 break;
            }
            if(myList.search(actual)==-1){
                myList.insert(actual);
            }

            int pos=findVertex(actual);
            for (int i = 0; i < 10; ++i) {
                if(edge[pos][i].exists){
                    if(myList.search(vertex[i].name)==-1){
                        stack.push(vertex[i].name);
                        couples.setActual(actual);
                        couples.setDestiny(vertex[i].name);
                        myStack.push(couples);
                    }
                }
            }
            if(stack.isEmpty()){
                cout<<"No path"<<endl;
            }
        }
    }else{
        cout<<"Vertex not Found"<<endl;
    }
}

template<class T>
void Graph<T>::showRute(Stack<Couples<T>> &stack,const T&destiny)
{
    T actual=destiny;

    while (!stack.isEmpty()) {
        cout<<actual<<",";
        Couples<T> temp=stack.getTop();
        while (!stack.isEmpty() and temp.getDestiny()!=actual) {
            stack.pop();
            temp=stack.getTop();
        }
        if(!stack.isEmpty()){
            actual=temp.getActual();
        }
    }
    cout<<endl;
}

Вот мой класс очереди и мой класс стека

    #ifndef QUEUE_H
    #define QUEUE_H

    #include <stdexcept>
    template <class T>
    class Queue{
    private:
        T queue[199];
        int index;
    public:
        Queue();
        void enqueue(const T&);
        T dequeue();
        bool isEmpty();
    };


    using namespace std;template<class T>
    Queue<T>::Queue()
    {
        index=0;
    }

    template<class T>
    void Queue<T>::enqueue(const T &d)
    {
        if(index>199){
            throw out_of_range("Full Queue");
        }
        queue[index++]=d;
    }

    template<class T>
    T Queue<T>::dequeue()
    {
        if(index==0){
            throw out_of_range("Empty Queue");
        }

        T temp=queue[0];
        for (int i = 0; i < index-1; ++i) {
           queue[i]=queue[i+1];
        }
        index--;

        return temp;
    }

    template<class T>
    bool Queue<T>::isEmpty()
    {
        return index==0;
    }

    #endif // QUEUE_H

#ifndef STACK_H
#define STACK_H

#include <stdexcept>
template<class T>

class Stack{
private:
    T stack[200];
    int index;
public:
    Stack();
    void push(const T&);
    T pop();
    bool isEmpty();
    T getTop();
    void deleteStack();
};


template<class T>
Stack<T>::Stack()
{
 index=0;
}

template<class T>
void Stack<T>::push(const T &d)
{
    if(index>199){
        throw std::out_of_range("StackOverflow");
    }
    stack[index++]=d;
}

template<class T>
T Stack<T>::pop()
{
    if(index==0){
        throw std::out_of_range("Stack Empty");
    }
    return stack[--index];
}

template<class T>
bool Stack<T>::isEmpty()
{
    return index==0;
}

template<class T>
T Stack<T>::getTop()
{
    return stack[index-1];
}

template<class T>
void Stack<T>::deleteStack()
{
    index=0;

}

#endif // STACK_H