C++ C++；带线程的网络类

我正在尝试使基于MSDN Winsocket示例创建的通信类正常工作：

构建时，我收到错误信息：

"Error  1   error C3867: 'Communication::AcceptClients': function call missing argument list; use '&Communication::AcceptClients' to create a pointer to member c:\users\bobby black\documents\visual studio 2012\projects\communication\communication\communication.cpp    67"

通过google阅读，我发现在类内创建线程时应该使用静态函数；但是在实现这个时，我似乎很难为该类实例分配connectSocket、listenSocket和*IP。我希望能够使用它们，以便可以使用client.Send（）。我知道服务器.Send（）当前无法工作。我只想让客户先发送

不使用预先构建的网络库，解决此问题的实用方法是什么

Source.cpp 通讯

#pragma一次
#未定义UNICODE
#定义WIN32_精益_和_平均值
#包括//标准：：打印格式
#include//std:：thread
#包括//WSADATA、SOCKET、ZeroMemory（）、WSACleanup（）、SOCKET（）、listen（）
#包括//睡眠
#包括//freeaddrinfo（），getaddrinfo（）
#pragma注释（lib，“Ws2_32.lib”）//外部引用
班级交流
{
公众：
插座连接插座；
SOCKET-listenSocket；
字符*IP；
int-Listen（PCSTR端口）；
void WINAPI AcceptClients（）；
void WINAPI Receive（）；
int Connect（PCSTR主机名、PCSTR端口）；
int发送（std：：字符串文本）；
};

Communication.cpp

#包括“Communication.h”
int通信：：侦听（PCSTR端口）
{
WSADATA WSADATA；
国际结果；
struct addrinfo*result=NULL，提示；
//初始化Winsock
iResult=WSAStartup（MAKEWORD（2,2）和wsaData）；
如果（iResult！=0）
{
printf_s（“WSAStartup失败，错误：%d\n”，iResult）；
返回0；
}
printf_s（“初始化Winsock完成”）；
零内存（&提示，sizeof（提示））；
hits.ai_family=AF_INET；
hits.ai_socktype=SOCK_流；
hits.ai_protocol=IPPROTO_TCP；
hits.ai_flags=ai_被动；
//解析服务器地址和端口
iResult=getaddrinfo（NULL、端口、提示和结果）；
如果（iResult！=0）
{
printf_s（“getaddrinfo失败，错误：%d\n”，iResult）；
WSACleanup（）；
返回0；
}
printf_s（“解析服务器地址和端口完成\n”）；
//创建用于连接到服务器的套接字
listenSocket=socket（结果->ai_族，结果->ai_socktype，结果->ai_协议）；
if（listenSocket==无效的_套接字）
{
printf_s（“套接字失败，错误：%ld\n”，WSAGetLastError（））；
freeaddrinfo（结果）；
WSACleanup（）；
返回0；
}
printf_s（“创建连接到服务器的套接字完成\n”）；
//设置TCP侦听套接字
iResult=bind（listenSocket，result->ai_addr，（int）result->ai_addrlen）；
if（iResult==SOCKET\u错误）
{
printf_s（“绑定失败，错误：%d\n”，WSAGetLastError（））；
freeaddrinfo（结果）；
闭合插座（listenSocket）；
WSACleanup（）；
返回0；
}
freeaddrinfo（结果）；
iResult=侦听（listenSocket，SOMAXCONN）；
if（iResult==SOCKET\u错误）
{
printf_s（“侦听失败，错误：%d\n”，WSAGetLastError（））；
闭合插座（listenSocket）；
WSACleanup（）；
返回0；
}
printf_s（“设置TCP侦听套接字完成”）；
//持续接受客户端套接字
std：：线程l（通信：：接受客户端）；
l、 分离（）；
printf_s（“持续接受正在运行的客户端套接字…\n”）；
返回1；
}
void WINAPI通信：：AcceptClients（）
{
客户端信息中的SOCKADDR\u={0}；
int addrsize=sizeof（客户信息）；
while（true）
{
connectSocket=accept（listenSocket，（struct sockaddr*）和client_info，&addrsize）；
while（connectSocket==SOCKET\u错误）
connectSocket=accept（listenSocket，（struct sockaddr*）和client_info，&addrsize）；
char*IP=inet\u ntoa（客户信息单地址）；
printf_s（“接受来自%s完成\n”，IP）；
std：：线程a（通信：：接收）；
a、 分离（）；
}
}
void WINAPI通信：：Receive（）
{
国际结果；
字符接收缓冲区[512]；
做
{
iResult=recv（connectSocket，receiveBuffer，512，0）；
if（iResult==SOCKET\u错误）
{
printf（“recv失败，错误：%d\n”，WSAGetLastError（））；
闭合插座（连接插座）；
WSACleanup（）；
回来
}
如果（iResult<512）
receiveBuffer[iResult]='\0'；
其他的
receiveBuffer[512]='\0'；
如果（iResult>0）
{
printf_s（“收到的字节数：%i-收到的数据：%s\n”，iResult，receiveBuffer）；
printf_s（“收到的数据：%s\n”，receiveBuffer）；
}
else if（iResult==0）
{
printf_s（“连接已关闭”）；
闭合插座（连接插座）；
WSACleanup（）；
回来
}
其他的
{
printf_s（“recv失败，错误：%d\n”，WSAGetLastError（））；
闭合插座（连接插座）；
WSACleanup（）；
回来
}
}而（iResult>0）；
//清理
闭合插座（连接插座）；
WSACleanup（）；
}
int通信：：连接（PCSTR主机名、PCSTR端口）
{
WSADATA WSADATA；
SOCKET connectSocket=无效的_套接字；
struct addrinfo*result=NULL，*ptr=NULL，提示；
国际结果；
//初始化Winsock
iResult=WSAStartup（MAKEWORD（2,2）和wsaData）；
如果（iResult！=0）{
printf（“WSAStartup失败，错误：%d\n”，iResult）；
返回0；
}
printf（“初始化Winsock完成\n”）；
零内存（&提示，sizeof（提示））；
hits.ai_family=AF_unsec；
hits.ai_socktype=SOCK_流；
hits.ai_protocol=IPPROTO_TCP；
//解析服务器地址和端口
iResult=getaddrinfo（主机名、端口、提示和结果）；
如果（iResult！=0）{
printf（“getaddrinfo失败，错误：%d\n”，iResult）；
WSACleanup（）；
返回0；
}
#include "Communication.h"

void main()
{
    Communication server;
    server.Listen("2000");
    Communication client;
    client.Connect("LOCALHOST", "2000");
    client.Send("Hello world!");
    Sleep(120000);
}

#pragma once

#undef UNICODE
#define WIN32_LEAN_AND_MEAN

#include <iostream>     // std::printf_s
#include <thread>       // std::thread
#include <winsock2.h>   // WSADATA, SOCKET, ZeroMemory(), WSACleanup(), socket(), listen()
#include <windows.h>    // Sleep
#include <ws2tcpip.h>   // freeaddrinfo(), getaddrinfo()
#pragma comment (lib, "Ws2_32.lib") //External References

class Communication
{
public:
    SOCKET connectSocket;
    SOCKET listenSocket;
    char *IP;
    int Listen(PCSTR port);
    void WINAPI AcceptClients();
    void WINAPI Receive();
    int Connect(PCSTR hostname, PCSTR port);
    int Send(std::string text);
};

#include "Communication.h"

int Communication::Listen(PCSTR port)
{
    WSADATA wsaData;
    int iResult;
    struct addrinfo *result = NULL, hints;

    // Initialize Winsock
    iResult = WSAStartup(MAKEWORD(2, 2), &wsaData);
    if (iResult != 0)
    {
        printf_s("WSAStartup failed with error: %d\n", iResult);
        return 0;
    }
    printf_s("Initialize Winsock complete\n");

    ZeroMemory(&hints, sizeof(hints));
    hints.ai_family = AF_INET;
    hints.ai_socktype = SOCK_STREAM;
    hints.ai_protocol = IPPROTO_TCP;
    hints.ai_flags = AI_PASSIVE;

    // Resolve the server address and port
    iResult = getaddrinfo(NULL, port, &hints, &result);
    if (iResult != 0)
    {
        printf_s("getaddrinfo failed with error: %d\n", iResult);
        WSACleanup();
        return 0;
    }
    printf_s("Resolve the server address and port complete\n");

    // Create a SOCKET for connecting to server
    listenSocket = socket(result->ai_family, result->ai_socktype, result->ai_protocol);
    if (listenSocket == INVALID_SOCKET)
    {
        printf_s("socket failed with error: %ld\n", WSAGetLastError());
        freeaddrinfo(result);
        WSACleanup();
        return 0;
    }
    printf_s("Create a SOCKET for connecting to server complete\n");

    // Setup the TCP listening socket
    iResult = bind(listenSocket, result->ai_addr, (int)result->ai_addrlen);
    if (iResult == SOCKET_ERROR)
    {
        printf_s("bind failed with error: %d\n", WSAGetLastError());
        freeaddrinfo(result);
        closesocket(listenSocket);
        WSACleanup();
        return 0;
    }
    freeaddrinfo(result);
    iResult = listen(listenSocket, SOMAXCONN);
    if (iResult == SOCKET_ERROR)
    {
        printf_s("listen failed with error: %d\n", WSAGetLastError());
        closesocket(listenSocket);
        WSACleanup();
        return 0;
    }
    printf_s("Setup the TCP listening socket complete\n");

    // Continuously accept a client socket
    std::thread l(Communication::AcceptClients);
    l.detach();
    printf_s("Continuously accept a client socket running...\n");

    return 1;
}

void WINAPI Communication::AcceptClients()
{
    SOCKADDR_IN client_info = { 0 };
    int addrsize = sizeof(client_info);
    while (true)
    {
        connectSocket = accept(listenSocket, (struct sockaddr*)&client_info, &addrsize);
        while (connectSocket == SOCKET_ERROR)
            connectSocket = accept(listenSocket, (struct sockaddr*)&client_info, &addrsize);
        char *IP = inet_ntoa(client_info.sin_addr);
        printf_s("accept from %s complete\n", IP);

        std::thread a(Communication::Receive);
        a.detach();
    }
}

void WINAPI Communication::Receive()
{
    int iResult;
    char receiveBuffer[512];
    do
    {
        iResult = recv(connectSocket, receiveBuffer, 512, 0);
        if (iResult == SOCKET_ERROR)
        {
            printf("recv failed with error: %d\n", WSAGetLastError());
            closesocket(connectSocket);
            WSACleanup();
            return;
        }
        if (iResult < 512)
            receiveBuffer[iResult] = '\0';
        else
            receiveBuffer[512] = '\0';
        if (iResult > 0)
        {
            printf_s("Bytes received: %i -  Data received: %s\n", iResult, receiveBuffer);
            printf_s("Data Received: %s\n", receiveBuffer);
        }
        else if (iResult == 0)
        {
            printf_s("Connection closed\n");
            closesocket(connectSocket);
            WSACleanup();
            return;
        }
        else
        {
            printf_s("recv failed with error: %d\n", WSAGetLastError());
            closesocket(connectSocket);
            WSACleanup();
            return;
        }
    } while (iResult > 0);

    // cleanup
    closesocket(connectSocket);
    WSACleanup();
}

int Communication::Connect(PCSTR hostname, PCSTR port)
{
    WSADATA wsaData;
    SOCKET connectSocket = INVALID_SOCKET;
    struct addrinfo *result = NULL, *ptr = NULL, hints;
    int iResult;

    // Initialize Winsock
    iResult = WSAStartup(MAKEWORD(2, 2), &wsaData);
    if (iResult != 0) {
        printf("WSAStartup failed with error: %d\n", iResult);
        return 0;
    }
    printf("Initialize Winsock complete\n");

    ZeroMemory(&hints, sizeof(hints));
    hints.ai_family = AF_UNSPEC;
    hints.ai_socktype = SOCK_STREAM;
    hints.ai_protocol = IPPROTO_TCP;

    // Resolve the server address and port
    iResult = getaddrinfo(hostname, port, &hints, &result);
    if (iResult != 0) {
        printf("getaddrinfo failed with error: %d\n", iResult);
        WSACleanup();
        return 0;
    }
    printf("Resolve the server address and port complete\n");

    // Attempt to connect to an address until one succeeds
    for (ptr = result; ptr != NULL; ptr = ptr->ai_next) {
        // Create a SOCKET for connecting to server
        connectSocket = socket(ptr->ai_family, ptr->ai_socktype, ptr->ai_protocol);
        if (connectSocket == INVALID_SOCKET) {
            printf("socket failed with error: %ld\n", WSAGetLastError());
            WSACleanup();
            return 0;
        }
        printf("Create a SOCKET for connecting to server complete\n");

        // Connect to server.
        iResult = connect(connectSocket, ptr->ai_addr, (int)ptr->ai_addrlen);
        if (iResult == SOCKET_ERROR) {
            closesocket(connectSocket);
            connectSocket = INVALID_SOCKET;
            continue;
        }
        printf("Connect to server complete\n");
        break;
    }
    freeaddrinfo(result);
    if (connectSocket == INVALID_SOCKET) {
        printf("Unable to connect to server!\n");
        WSACleanup();
        return 0;
    }
    printf("Attempt to connect to an address until one succeeds complete\n");

    std::string tempIP = hostname;
    char *IP = new char[tempIP.length() + 1];
    strcpy(IP, tempIP.c_str());

    // Receive until the peer closes the connection
    std::thread c(Communication::Receive);
    c.detach();
    printf("Receive until the peer closes the connection running...\n");

    return 1;
}

int Communication::Send(std::string text)
{
    char *sendBuffer = new char[text.length() + 1];
    strcpy(sendBuffer, text.c_str());

    // Send text
    int iResult;
    iResult = send(connectSocket, sendBuffer, (int)strlen(sendBuffer), 0);
    if (iResult == SOCKET_ERROR) {
        printf("send failed with error: %d\n", WSAGetLastError());
        closesocket(connectSocket);
        WSACleanup();
        return 0;
    }

    printf("Bytes Sent: %ld - Data Sent: %s\n", iResult, sendBuffer);
    return 1;
}