c+中的客户机/服务器程序+；问题 我在C++的基础上在Windows套接字上创建了一个客户机和服务器程序。 我有一个问题，当我执行程序时，服务器端没有消息出现，然后程序退出。数据正在发送到服务器，但它没有响应

我正在下面粘贴我的代码

****Server code
===========****

#ifndef WIN32_LEAN_AND_MEAN
#define WIN32_LEAN_AND_MEAN
#endif

#include <windows.h>
#include <winsock2.h>
#include <ws2tcpip.h>
#include <iphlpapi.h>
#include <stdio.h>
#include <conio.h>

#define DEFAULT_PORT        "27015" 
#define DEFAULT_BUFLEN      512
#pragma comment(lib, "Ws2_32.lib")

int main() {
    WSADATA wsdata;
    int result = WSAStartup(MAKEWORD(2,2),&wsdata);
    if(result != 0){
        printf("%s","Unable to initilize windows socket\n");
        getch();
        return 1;
    }
    struct addrinfo *addrResult = NULL,hints;
    ZeroMemory(&hints, sizeof (hints));

    hints.ai_family = AF_INET;
    hints.ai_socktype = SOCK_STREAM;
    hints.ai_protocol = IPPROTO_TCP;
    hints.ai_flags = AI_PASSIVE;

    result = getaddrinfo(NULL,DEFAULT_PORT,&hints,&addrResult);
    if(result != 0){
        printf("%s","Error in getaddrInfo");
        getch();
        return 1;
    }
    SOCKET listenSocket = INVALID_SOCKET;
    listenSocket = socket(addrResult->ai_family,addrResult->ai_socktype,addrResult->ai_protocol);
    if(listenSocket == INVALID_SOCKET){
        printf("%s","Error in creating socket object\n");
        getch();
        closesocket(listenSocket);
        WSACleanup();
        return 1;
    }

    sockaddr_in service;
    service.sin_family = AF_INET;
    service.sin_addr.s_addr = inet_addr("127.0.0.1");
    service.sin_port = htons(27015);

    if( bind(listenSocket,addrResult->ai_addr,
        (int)addrResult->ai_addrlen) == SOCKET_ERROR){
    //if(bind(listenSocket,(SOCKADDR*) &service,
    //  sizeof(service)) == SOCKET_ERROR){

        printf("bind failed: %d\n", WSAGetLastError());
        freeaddrinfo(addrResult);
        closesocket(listenSocket);
        WSACleanup();
        getch();
        return 1;

    }
    freeaddrinfo(addrResult);
    if(listen(listenSocket,SOMAXCONN) == SOCKET_ERROR){
        printf("%s","Error in listening socket");
        getch();
        closesocket(listenSocket);
        WSACleanup();
    }
    SOCKET clientSocket = INVALID_SOCKET;
    clientSocket = accept((listenSocket,NULL,NULL);
    if(clientSocket ==  INVALID_SOCKET){
        closesocket(listenSocket);
        WSACleanup();
    }

    char recvbuf[DEFAULT_BUFLEN];
    int iRecvResult, iSendResult;
    int recvbuflen = DEFAULT_BUFLEN;

    do{
        iRecvResult = 0;
        iSendResult = 0;
        iRecvResult = recv(clientSocket,recvbuf,recvbuflen,0);
        if(iRecvResult > 0){
            printf("Bytes received: %d\n", iRecvResult);
            getch();
            // Echo the buffer back to the sender
            iSendResult = send(clientSocket, recvbuf, iRecvResult, 0);
            if (iSendResult == SOCKET_ERROR) {
                printf("send failed: %d\n", WSAGetLastError());
                closesocket(clientSocket);
                WSACleanup();
                return 1;
            }
            printf("Bytes sent: %d\n", iSendResult);
        }
        else if (iRecvResult == 0){
            printf("Connection closing...\n");
        }
        else{
            printf("recv failed: %d\n", WSAGetLastError());
            closesocket(clientSocket);
            WSACleanup();
            return 1;
        }
    }while(iRecvResult > 0);
  getch();
  return 0;
}


**client code
============**


#ifndef WIN32_LEAN_AND_MEAN
#define WIN32_LEAN_AND_MEAN
#endif

#include <windows.h>
#include <winsock2.h>
#include <ws2tcpip.h>
#include <iphlpapi.h>
#include <stdio.h>
#include <conio.h>

#define DEFAULT_PORT        "27015" 
#define DEFAULT_BUFLEN      512
#pragma comment(lib, "Ws2_32.lib")

int main(){
    WSADATA wsdata;
    WSAStartup(MAKEWORD(2,2),&wsdata);
    struct addrinfo *addrResult = NULL,hints;
    ZeroMemory(&hints, sizeof (hints));
    hints.ai_protocol = IPPROTO_TCP;
    hints.ai_socktype = SOCK_STREAM;
    hints.ai_family = AF_UNSPEC;
    int result = 0;
    if(getaddrinfo("127.0.0.1",DEFAULT_PORT,
        &hints,&addrResult)){
            printf("%s","Error in getaddrInfo\n");
            WSACleanup();
            getch();
            return 1;
    }
    SOCKET connectingSocket = INVALID_SOCKET; 
    connectingSocket = socket(addrResult->ai_family,addrResult->ai_socktype,
        addrResult->ai_protocol);
    if(connectingSocket == INVALID_SOCKET){
        printf("%s","Error in creating socket\n");
        freeaddrinfo(addrResult);
        WSACleanup();
        getch();
        return 1;
    }

        if(connect(connectingSocket,addrResult->ai_addr, (int)addrResult->ai_addrlen) != 0){
        closesocket(connectingSocket);
        connectingSocket = INVALID_SOCKET;
        WSACleanup();

    }
    freeaddrinfo(addrResult);

    int recvbuflen = DEFAULT_BUFLEN;
    char *sendbuf = "this is a test";
    char recvbuf[DEFAULT_BUFLEN];

    int iResult;

    // Send an initial buffer
    iResult = send(connectingSocket, sendbuf, (int) strlen(sendbuf), 0);
    if (iResult == SOCKET_ERROR) {
        printf("send failed: %d\n", WSAGetLastError());
        closesocket(connectingSocket);
        WSACleanup();
        return 1;
    }

    printf("Bytes Sent: %ld\n", iResult);

    // shutdown the connection for sending since no more data will be sent
    // the client can still use the connectingSocket for receiving data
    iResult = shutdown(connectingSocket, SD_SEND);
    if (iResult == SOCKET_ERROR) {
        printf("shutdown failed: %d\n", WSAGetLastError());
        closesocket(connectingSocket);
        WSACleanup();
        return 1;
    }

    // Receive data until the server closes the connection
    do {
        iResult = recv(connectingSocket, recvbuf, recvbuflen, 0);
        if (iResult > 0)
            printf("Bytes received: %d\n", iResult);
        else if (iResult == 0)
            printf("Connection closed\n");
        else
            printf("recv failed: %d\n", WSAGetLastError());
    } while (iResult > 0);




    getch();
    return 0;
}

****服务器代码
===========****
#如果NDEF WIN32_LEAN_和_MEAN
#定义WIN32_精益_和_平均值
#恩迪夫
#包括
#包括
#包括
#包括
#包括
#包括
#定义默认_端口“27015”
#定义默认值\u BUFLEN 512
#pragma注释（lib，“Ws2_32.lib”）
int main（）{
WSADATA-wsdata；
int result=WSAStartup（MAKEWORD（2,2）和wsdata）；
如果（结果！=0）{
printf（“%s”，“无法初始化windows套接字\n”）；
getch（）；
返回1；
}
struct addrinfo*addrResult=NULL，提示；
零内存（&提示，sizeof（提示））；
hits.ai_family=AF_INET；
hits.ai_socktype=SOCK_流；
hits.ai_protocol=IPPROTO_TCP；
hits.ai_flags=ai_被动；
结果=getaddrinfo（NULL、默认端口、提示和addrResult）；
如果（结果！=0）{
printf（“%s”，“getaddrInfo中的错误”）；
getch（）；
返回1；
}
套接字listenSocket=无效的\u套接字；
listenSocket=socket（addrResult->ai_族，addrResult->ai_socktype，addrResult->ai_协议）；
if（listenSocket==无效的_套接字）{
printf（“%s”，“创建套接字对象时出错\n”）；
getch（）；
闭合插座（listenSocket）；
WSACleanup（）；
返回1；
}
正在使用的sockaddr_；
service.sinu family=AF\u INET；
service.sin_addr.s_addr=inet_addr（“127.0.0.1”）；
service.sinu port=htons（27015）；
如果（绑定）（listenSocket，addrResult->ai_addr，
（int）addrResult->ai_addrlen）=套接字错误）{
//如果（绑定（listenSocket，（SOCKADDR*）和服务，
//sizeof（服务））==套接字错误）{
printf（“绑定失败：%d\n”，WSAGetLastError（））；
freeaddrinfo（addrResult）；
闭合插座（listenSocket）；
WSACleanup（）；
getch（）；
返回1；
}
freeaddrinfo（addrResult）；
if（侦听（listenSocket，SOMAXCONN）=套接字错误）{
printf（“%s”，“侦听套接字中出错”）；
getch（）；
闭合插座（listenSocket）；
WSACleanup（）；
}
套接字clientSocket=无效的\u套接字；
clientSocket=accept（（listenSocket，NULL，NULL）；
if（clientSocket==无效的_SOCKET）{
闭合插座（listenSocket）；
WSACleanup（）；
}
char recvbuf[默认值]；
int iRecvResult，iSendResult；
int recvbuflen=默认值；
做{
iRecvResult=0；
iSendResult=0；
iRecvResult=recv（clientSocket，recvbuf，recvbuflen，0）；
如果（iRecvResult>0）{
printf（“收到的字节数：%d\n”，iRecvResult）；
getch（）；
//将缓冲区回显给发送方
iSendResult=send（clientSocket，recvbuf，iRecvResult，0）；
if（iSendResult==套接字错误）{
printf（“发送失败：%d\n”，WSAGetLastError（））；
闭合插座（clientSocket）；
WSACleanup（）；
返回1；
}
printf（“发送的字节数：%d\n”，iSendResult）；
}
else if（iRecvResult==0）{
printf（“连接关闭…\n”）；
}
否则{
printf（“recv失败：%d\n”，WSAGetLastError（））；
闭合插座（clientSocket）；
WSACleanup（）；
返回1；
}
}而（iRecvResult>0）；
getch（）；
返回0；
}
**客户端代码
============**
#如果NDEF WIN32_LEAN_和_MEAN
#定义WIN32_精益_和_平均值
#恩迪夫
#包括
#包括
#包括
#包括
#包括
#包括
#定义默认_端口“27015”
#定义默认值\u BUFLEN 512
#pragma注释（lib，“Ws2_32.lib”）
int main（）{
WSADATA-wsdata；
WSAStartup（MAKEWORD（2,2）和wsdata）；
struct addrinfo*addrResult=NULL，提示；
零内存（&提示，sizeof（提示））；
hits.ai_protocol=IPPROTO_TCP；
hits.ai_socktype=SOCK_流；
hits.ai_family=AF_unsec；
int结果=0；
如果（getaddrinfo（“127.0.0.1”），则默认为，
&提示和添加结果）{
printf（“%s”，“getaddrInfo中的错误\n”）；
WSACleanup（）；
getch（）；
返回1；
}
插座连接插座=无效的_插座；
connectingSocket=socket（addrResult->ai_系列，addrResult->ai_socktype，
addrResult->ai_协议）；
if（connectingSocket==无效的_SOCKET）{
printf（“%s”，“创建套接字时出错\n”）；
freeaddrinfo（addrResult）；
WSACleanup（）；
getch（）；
返回1；
}
if（connect（connectingSocket，addrResult->ai_addr，（int）addrResult->ai_addrlen）！=0）{
闭合插座（连接插座）；
ConnectionSocket=无效的_套接字；
WSACleanup（）；
}
freeaddrinfo（addrResult）；
int recvbuflen=默认值；
char*sendbuf=“这是一个测试”；
char recvbuf[默认值]；
国际结果；
//发送初始缓冲区
iResult=send（connectingSocket，sendbuf，（int）strlen（sendbuf），0）；
if（iResult==SOCKET\u错误）{
printf（“发送失败：%d\n”，WSAGetLastError（））；
闭合插座（连接插座）；
WSACleanup（）；
返回1；
}
printf（“发送的字节数：%ld\n”，iResult）；
//由于不再发送数据，请关闭发送连接
//客户端仍然可以使用ConnectionSocket接收数据
iResult=关机（连接套接字，SD_发送）；
if（iResult==SOCKET\u错误）{
printf（“关闭失败：%d\n”，WSAGetLastError（））；
闭合插座（连接插座）；
WSACleanup（）；
返回1；
}
//在服务器关闭连接之前接收数据
做{
iResult=recv（connectingSocket，recvbuf，recvbuflen，0）；
如果（iResult>0）
printf（“收到的字节数：%d\n”，iResult）；
else if（iResult==0）
printf（“连接关闭\n”）；
E