C++ c++&书信电报；排队>；字符串类成员|访问错误

我知道在这个话题上已经有很多问题了，但不幸的是我无法真正理解它们：(

一方面，我读到必须初始化队列，另一方面，我读到必须在类本身中引用队列

也许有人可以用我的代码或错误向我解释这个问题

Hier das问题im调试器：

Hier mein Main.cpp:

intmain（intargc，char*argv[]）
{
字符串测试；
//DekLation是共享指针auf die服务器Klasse um es，位于线程初始化器和线程aufrufen zu können中。
std:：shared_ptr ServerDienst（nullptr）；
//服务器已启动
std:：线程StartServerService（[&]{
std:：cout该地址有效，但可疑地接近0。可能是在无效指针或引用上调用了该函数，可能是在
nullptr
上。使用调试器并检查调用堆栈。
int main(int argc, char* argv[])
{
    std::string test;
    //Deklaration eines shared Pointer auf die server-Klasse um es in einem Thread später zu initialiseren und außerhalb des Threads aufrufen zu können.
    std::shared_ptr<server> ServerDienst(nullptr);
    
    //Server Dienst für die Prüfrechner starten
    std::thread StartServerService([&]{
        std::cout<<"TCP/-IPv4 Serverdienst starten"<<std::endl; 
        ServerDienst = std::make_shared<server>(8000);
        std::cout<<"Serverdienst läuft"<<std::endl; 
    });    

    while(true) 
        {
            test.clear();
            std::cout<<"1.."<<std::endl;
            if(ServerDienst->pop_RCVD_Data(test) == 0)
            {
                std::cout<<"1 Emfpangen: "<< test << std::endl;    
            }
            std::cout<<"3.."<<std::endl;
            std::cout<<"1Warte auf Daten..."<<std::endl;
            std::this_thread::sleep_for(1s);
        }
    StartServerService.join();

//Include-Protection
#ifndef _Server_H_
#define _Server_H_

#include <WS2tcpip.h>
#include <iostream>
#include <cstring>
#include <mutex>
#include <memory>
#include <vector>
#include <thread>
#include <queue>
#include <chrono>
#include "server.h"
#include "connection.h"

class server
{
private:
    //System Variablen für den Server Dienst
    WSADATA WINSYS_SOCKETDATA;
    SOCKET SERVICE_SOCKET;
    sockaddr_in HINT;
    int SERVICE_USED_PORT;
    //Server Status und letzte Fehlermeldung
    int S_STATUS;
    std::mutex mx_S_STATUS;
    std::string lastWSA_Error;
    std::mutex mx_lastWSA_Error;   
    //Vector aus ptr auf connection Klasse -> Objekt(e) Verbindungen //Konstruktor ?!?!?! möglichkeit serverklasse zu übergeben doppelter aufruf der jeweiligen header problematisch
    std::vector<std::shared_ptr<connection>>RemoteVerbindungen;
    //Vector aus thread Objekten um die Verbindungen zu "steuern"
    std::vector<std::thread>th_RemoteVerbindungen;
    std::vector<std::thread>th_read_RemoteVerbindungen;
    unsigned int AnzahlVerbundenerClients;
    std::mutex mx_AnzahlVerbundenerClients; 
    //queue für von die Daten aus den einzelnen Verbindungen
    std::queue<std::string>emfangeneDaten;
    std::mutex mx_emfangeneDaten;
    
public:
    //Konstruktor(en)
    server(const int &PORT);
    server(const server &) = delete;
    ~server();
    //Methoden
    SOCKET getServiceSocket(){return (SERVICE_SOCKET);};
    int getS_Status();
    int pop_RCVD_Data(std::string &FiFo_Buffer_pop);
};

#endif //_Server_H_

#include "server.h"

//Für aus Chrono generierter resume Zeit
using namespace std::literals::chrono_literals;
//Standart-Konstruktor
//Windows System Sockets werden geladen und initialiserit
//Socket wird mit TCP/IPv4 Verbindungsinfortationen gebunden und ist bereit Verbindung
//anzunehmen, andernfalls ist der Status < 0
server::server(const int &PORT)
: S_STATUS(0)
, SERVICE_USED_PORT(PORT)
, lastWSA_Error("NONE")
, SERVICE_SOCKET(-1)
, AnzahlVerbundenerClients(0)
, emfangeneDaten({0})
{
    //WS2_32.dll Funktion WSAStartup der höchsten Version der Winsock auf dem ausführendem System aufrufen.
    if (WSAStartup(MAKEWORD(2, 2), &WINSYS_SOCKETDATA) != 0){   
        mx_S_STATUS.lock();
        mx_lastWSA_Error.lock();
        S_STATUS = -1;
        lastWSA_Error = ("Winsock initialisierung fehlgeschlagen");
        mx_S_STATUS.unlock();
        mx_lastWSA_Error.unlock();    
    }   
    //IPv4 TCP Socket von System anfordern/erstellen
    SERVICE_SOCKET = socket(AF_INET, SOCK_STREAM,0);
    if (SERVICE_SOCKET == INVALID_SOCKET){
        mx_S_STATUS.lock();
        mx_lastWSA_Error.lock();
        S_STATUS = -1;
        lastWSA_Error = ("Socket konnte nicht erstellt werden");
        mx_S_STATUS.unlock();
        mx_lastWSA_Error.unlock(); 
    }
    HINT.sin_family = AF_INET;                      //Streamorientiertes TCP IPv4 Protokoll verwenden
    HINT.sin_port = htons(SERVICE_USED_PORT);       //Port den der Server Dienst nutzen soll, wird über Konstruktor vorgegeben
    HINT.sin_addr.S_un.S_addr = INADDR_ANY;         //Jeglichem Interface bind mit Socket ermöglichen
    
    //Erstelltes Socket mit sockaddr. Info binden
    if (bind(SERVICE_SOCKET,(sockaddr*)&HINT, sizeof(HINT)) == SOCKET_ERROR)
    {
        mx_S_STATUS.lock();
        mx_lastWSA_Error.lock();
        S_STATUS = -1;
        lastWSA_Error = (WSAGetLastError());
        mx_S_STATUS.unlock();
        mx_lastWSA_Error.unlock();
        closesocket(SERVICE_SOCKET);
        WSACleanup(); 
    }
    
    //Socket auf listen switchen und auf Remoteverbindungen warten
    if(listen(SERVICE_SOCKET,SOMAXCONN) == SOCKET_ERROR)
    {
        mx_S_STATUS.lock();
        mx_lastWSA_Error.lock();
        S_STATUS = -2;
        lastWSA_Error = (WSAGetLastError());
        mx_S_STATUS.unlock();
        mx_lastWSA_Error.unlock();
    }

    mx_S_STATUS.lock();
    S_STATUS = 0;
    mx_S_STATUS.unlock();
    
    //Verbindungen annehmen und abspalten
    std::thread ManageRemoteVerbindungen([&]{
        do
        {   
            //Neue Verbindung anlegen (Vektor um Speicherbereich erweitern)     
            RemoteVerbindungen.push_back(std::make_shared<connection>(SERVICE_SOCKET));
            //Iterator positionieren
            auto Verbindungen = RemoteVerbindungen.begin()+AnzahlVerbundenerClients;            
            //Thread startet "starUp Methode" für neues Connection Objekt    
            th_RemoteVerbindungen.push_back(std::thread([&]{(*Verbindungen)->startUp(this->emfangeneDaten,this->mx_emfangeneDaten);}));
            auto th_Verbindung = th_RemoteVerbindungen.begin()+AnzahlVerbundenerClients;
            //Warte bis ein Client ueber accept verbunden hat
            while ((*Verbindungen)->getState() == 0 || (*Verbindungen)->getState() ==  1)
            {
                std::cout<< "Verbindung Nr: "<< RemoteVerbindungen.size() <<" Warte auf Remote Verbindungsstatus: "<< (*Verbindungen)->getState() << std::endl;          
                std::this_thread::sleep_for(1.575s);
            }
            mx_AnzahlVerbundenerClients.lock();
            AnzahlVerbundenerClients++;
            mx_AnzahlVerbundenerClients.unlock();
            std::this_thread::sleep_for(0.175s);
        } while(true);//Abbruch bedingung einbauen!
    });
    ManageRemoteVerbindungen.join();
}

//Standart-Destruktor
server::~server()
{
    closesocket(SERVICE_SOCKET);
    WSACleanup();
}

int server::getS_Status()
{
    int temp;
    mx_S_STATUS.lock();
    temp = S_STATUS;
    mx_S_STATUS.unlock();   
    return (temp); 
}

int server::pop_RCVD_Data(std::string &FiFo_Buffer_pop)
{
    //this->mx_emfangeneDaten.lock();
    std::cout<<"2.."<<std::endl;

    if(emfangeneDaten.size() > 0)     // if(!emfangeneDaten.empty()){ 
    {                         
        std::cout<<"3ne.."<<std::endl;
        FiFo_Buffer_pop.append(emfangeneDaten.front());
        //Element aus FiFo löschen
        emfangeneDaten.pop(); 
        mx_emfangeneDaten.unlock();
        return 0; 
    }
    std::cout<<"3e.."<<std::endl;


    mx_emfangeneDaten.unlock();
    return -1;  
}