C++ 试图引用线程套接字类上xmemory0中已删除的函数

我正在努力完成这个线程套接字类。到目前为止，我得到的是：

#pragma once
#include <winsock2.h>
#include <ws2tcpip.h>
#include <stdio.h>
#include <atomic>
#include <thread>
#include <vector>
#pragma comment(lib, "Ws2_32.lib")
//---------------------------------------------------CLASS
class AsyncSockets
{
public:
    int StartSockets(int, void(*)(SOCKET, sockaddr*, int, std::atomic<bool>&));
    static const int FAIL_SUCCESS, FAIL_INIT_WS, FAIL_BIND_SOCKET, FAIL_ASYNCSELECT, FAIL_LISTEN, FAIL_ACCEPT;
    bool StopSockets();
private:
    /*static*/ void(*Functiane)(SOCKET, sockaddr*, int, std::atomic<bool>&);
    struct RunThread {
        std::thread Thread;
        std::atomic<bool> Running = true;
    };
    void AcceptLoop();
    SOCKET Socket; std::atomic<bool> running = false;
    std::vector<AsyncSockets::RunThread>ThreadList;
    void StartFunc(SOCKET, sockaddr*, int, int);
    std::thread loopaccepter;
    std::thread deleteInvalid;
};
//-------------------------------------STARTFUNC---PRIVATE
void AsyncSockets::StartFunc(SOCKET socketa, sockaddr* sockaddra, int sockaddrinfolena, int BoolIndex) {
    if (socketa != INVALID_SOCKET) {
        (*Functiane)(socketa, sockaddra, sockaddrinfolena, ThreadList[BoolIndex].Running);
    }else{
        closesocket(socketa); ThreadList[BoolIndex].Running = false; return;
    }
    closesocket(socketa);
    ThreadList[BoolIndex].Running = false;
    return;
}
//------------------------------------ACCEPTLOOP---PRIVATE
void AsyncSockets::AcceptLoop() {
    while (true) {
        struct sockaddr *AddressInfo = NULL; int addrinfoLen;
        if (running) {
            int temp = ThreadList.size();
            for (int i = 0; i < temp; i++){
                if (i != temp - 1) {
                    if (!ThreadList[i].Running){
                        if (ThreadList[i].Thread.joinable()) ThreadList[i].Thread.join();
                        ThreadList[i].Running = true; ThreadList[i].Thread = std::thread(&AsyncSockets::StartFunc, this, accept(Socket, AddressInfo, &addrinfoLen), AddressInfo, addrinfoLen, i); }
                }else{
                    if (!ThreadList[i].Running) { 
                        if (ThreadList[i].Thread.joinable()) ThreadList[i].Thread.join();
                        ThreadList[i].Running = true; ThreadList[i].Thread = std::thread(&AsyncSockets::StartFunc, this, accept(Socket, AddressInfo, &addrinfoLen), AddressInfo, addrinfoLen, i);}
                    else { ThreadList.push_back({ std::thread(&AsyncSockets::StartFunc, this, accept(Socket, AddressInfo, &addrinfoLen), AddressInfo, addrinfoLen, i + 1), true });}
                }
            }

        }else return;
    }
}
//-----------------------------------STARTSOCKETS---PUBLIC
int AsyncSockets::StartSockets(int port, void(*functian)(SOCKET, sockaddr*, int, std::atomic<bool>&)) {

    //DeclaringShiet
    int recvbuflen = 512;

    //InitWinsock
    WSADATA WsaDat;
    int nResult = WSAStartup(MAKEWORD(2, 2), &WsaDat);
    if (nResult != 0)
    {
        return FAIL_INIT_WS;
    }

    //BuildAddr
    SOCKADDR_IN SockAddr;
    SockAddr.sin_port = htons(port);
    SockAddr.sin_family = AF_INET;
    SockAddr.sin_addr.s_addr = htonl(INADDR_ANY);

    //BindSocket
    if (bind(Socket, (LPSOCKADDR)&SockAddr, sizeof(SockAddr)) == SOCKET_ERROR)
    {
        return FAIL_BIND_SOCKET;
    }
    //StartListening
    if (listen(Socket, 10) == SOCKET_ERROR)
    {
        return FAIL_LISTEN;
    }
    //StartAccepting
    running = true;
    Functiane = (*functian);
    loopaccepter = std::thread(&AsyncSockets::AcceptLoop, this);
}
//------------------------------------STOPSOCKETS---PUBLIC
bool AsyncSockets::StopSockets() {
    running = false;
    loopaccepter.join();
    closesocket(Socket);
    for (unsigned int i = 0; i < ThreadList.size(); i++)ThreadList[i].Running = false;
    for (unsigned int i = 0; i < ThreadList.size(); i++)if(ThreadList[i].Thread.joinable())ThreadList[i].Thread.join();
    return true;
}
//------------------------------------ERRORCONSTS---PUBLIC
#pragma region DeclaringErrorConsts
const int
AsyncSockets::FAIL_SUCCESS = 0x0,
AsyncSockets::FAIL_INIT_WS = 0x1,
AsyncSockets::FAIL_BIND_SOCKET = 0x2,
AsyncSockets::FAIL_LISTEN = 0x3,
AsyncSockets::FAIL_ACCEPT = 0x4;
#pragma endregion

#pragma一次
#包括
#包括
#包括
#包括
#包括
#包括
#pragma注释（lib，“Ws2_32.lib”）
//---------------------------------------------------阶级
类异步套接字
{
公众：
int StartSockets（int，void（*）（SOCKET，sockaddr*，int，std:：atomic&））；
静态常量int FAIL\u SUCCESS、FAIL\u INIT\u WS、FAIL\u BIND\u SOCKET、FAIL\u ASYNCSELECT、FAIL\u LISTEN、FAIL\u ACCEPT；
bool StopSockets（）；
私人：
/*static*/void（*Functiane）（SOCKET，sockaddr*，int，std:：atomic&）；
结构运行线程{
标准：螺纹；
std:：原子运行=真；
};
void AcceptLoop（）；
套接字；标准：：原子运行=false；
std:：vectorThreadList；
void StartFunc（SOCKET，sockaddr*，int，int）；
线程环接受器；
std：：线程删除无效；
};
//-------------------------------------STARTFUNC——私人
void AsyncSockets:：StartFunc（SOCKET socketa、sockaddr*sockaddra、int sockaddrinfolena、int BoolIndex）{
if（socketa！=无效的_插座）{
（*Functiane）（socketa、sockaddra、sockaddrinfolena、ThreadList[BoolIndex]。正在运行）；
}否则{
closesocket（socketa）；ThreadList[BoolIndex]。Running=false；返回；
}
闭合插座（插座）；
ThreadList[BoolIndex]。Running=false；
返回；
}
//------------------------------------接受循环---私有
void AsyncSockets:：AcceptLoop（）{
while（true）{
结构sockaddr*AddressInfo=NULL；int addrinfoLen；
如果（正在运行）{
int temp=ThreadList.size（）；
对于（int i=0；i

所以，正如您可能已经注意到的，我正试图用std:：thread、vectors和winsock来实现这一点。关键是要有一个函数作为StartSockets的参数，它将完成所有的发送、接收和处理。
线程对象将存储在RunThread类型的向量中，该向量包含一个原子bool，该原子bool告诉线程是否正在/应该正在运行，以及线程对象

我的问题是我得到了一个

'AsyncSockets:：RunThread:：RunThread（const AsyncSockets:：RunThread&）'：尝试引用已删除的函数

在

xmemory0（第840行）

（c:\ProgramFiles（x86）\microsoft visual studio\2017\community\vc\tools\msvc\14.10.24728\include\xmemory0）

我不知道为什么，因为RunThread是一个结构而不是一个函数，再加上RunThread:：RunThread毫无意义，我一点也不明白到底发生了什么。如果它可以帮助任何进一步，我在VS2017 RC上的windows 10，win32控制台应用程序

我做错了什么？

---

谢谢。

std:：vector:“
std:：thread
不是”）。在C++11之前，复制可构造性是必需的。从C++11开始，这取决于您对
std:：vector
执行的操作，该操作对模板参数类型施加了额外的限制。但是，您的
push_back
调用需要复制可构造性。如果你把它换成你应该很好。