进程间TCP网络通信(C++)

使用者只要将这服务端和客户端分别复制到两个工程就可以使用，注意自己工程中有主函数的时候，不要将这边的也复制过去
服务器端：

#include <cstdlib>
#include <iostream>
#include <winsock.h>
#pragma comment(lib, "ws2_32.lib")

class Sever
{
public:
    Sever(int port);
    ~Sever();
    void connect();
    void sendMes();
    void closeSocket();
private:
    void initSocket();
private:
    int m_iPort;

    SOCKET m_sSeverSocket;
    SOCKET m_sClientSocket;

    sockaddr_in m_severAddr;

};

Sever::Sever(int port)
    :m_iPort(port)
{
    
    //初始化套接字库
    initSocket();

    m_severAddr.sin_family = AF_INET;

    //不使用指定IP地址
    m_severAddr.sin_addr.S_un.S_addr = htonl(INADDR_ANY);
    m_severAddr.sin_port = htons(port);

    //创建套接字
    m_sSeverSocket = socket(AF_INET, SOCK_STREAM, 0);
 
}

void Sever::connect()
{
    //绑定套接字
    int re = bind(m_sSeverSocket, (SOCKADDR*)&m_severAddr, sizeof(SOCKADDR));
    if (re < 0)
    {
        std::cout << "服务器绑定失败" << std::endl;
        WSACleanup();
    }
    else
    {
        std::cout << "服务器绑定成功" << std::endl;
    }

    //监听套接字
    int error = listen(m_sSeverSocket, SOMAXCONN);
    if (error < 0)
    {
        std::cout << "服务器监听失败" << std::endl;
        WSACleanup();
    }
    else
    {
        std::cout << "服务器监听成功" << std::endl;
    }

    sockaddr_in clientAddr;
    int len = sizeof(SOCKADDR);

    //接受客户端，并返回客户端套接字
    m_sClientSocket = accept(m_sSeverSocket, (SOCKADDR*)&clientAddr, &len);
    if (m_sClientSocket == SOCKET_ERROR)
    {
        std::cout << "接受失败!" << std::endl;
        WSACleanup();
        return;
    }
    else
    {

        std::cout << "创建连接成功，客户端端口号：!" << ntohs(clientAddr.sin_port)<<std::endl;
    }

}

 void Sever::sendMes()
{
    char clientBuf[1024];
    char sendMes[1024];
    int revLen = 0;
    while (true)
    {
        //接受客户端发来的消息
        revLen = recv(m_sClientSocket, clientBuf, 1024, 0);
        if (revLen < 0)
        {
            std::cout << "接受消息失败" << std::endl;
        }
        else
        {
            std::cout << "客户端消息为：" << clientBuf << std::endl;
        }

        std::cout << "请输入回复消息：";
        std::cin >> sendMes;

        //向客户端发送消息
        int senLen = send(m_sClientSocket, sendMes, 1024, 0);
        if (senLen < 0)
        {
            std::cout << "回复消息失败" << std::endl;
            break;
        }
        else
        {
            std::cout << "消息发送成功" << std::endl;
        }
    }

    closeSocket();
}

void Sever::initSocket()
{
    //初始化套接字库
    WORD wSever = MAKEWORD(2, 2);
    WSADATA wsData;
    int err;
    err = WSAStartup(wSever, &wsData);
    if (err != 0)
    {
        std::cout << "套接字库初始化失败" << std::endl;
    }
    else
    {
        std::cout << "套接字库初始化成功" << std::endl;
    }

    //检测版本
    if (LOBYTE(wsData.wVersion) != 2 || HIBYTE(wsData.wHighVersion) != 2)
    {
        std::cout << "套接字库版本不符合" << std::endl;
        WSACleanup();
    }
    else
    {
        std::cout << "套接字版本号正确" << std::endl;
    }
}

void Sever::closeSocket()
{
    closesocket(m_sSeverSocket);
    closesocket(m_sClientSocket);
    WSACleanup();
}

Sever::~Sever()
{
    closeSocket();
}

int main()
{
    Sever *sever = new Sever(8888);
    sever->connect();
    sever->sendMes();
    return 0;
}

客户端：

#include <iostream>
#include <winsock.h>
#pragma comment(lib, "ws2_32.lib")

class Client
{
public:
    Client(int port);
    ~Client();

    void linkSever();

    void sendMesg();
private:
    void initSocket();
private:
    SOCKET m_sClientSocket;

    sockaddr_in m_cilentAddr;
};

Client::Client(int port)
{
    initSocket();

    m_cilentAddr.sin_family = AF_INET;
    m_cilentAddr.sin_addr.S_un.S_addr = inet_addr("127.0.0.1");
    m_cilentAddr.sin_port = htons(port);

    //创建套接字
    m_sClientSocket = socket(AF_INET, SOCK_STREAM, 0);

}

void Client::linkSever()
{
    //连接服务器
    int err = connect(m_sClientSocket, (SOCKADDR*)&m_cilentAddr, sizeof(SOCKADDR));
    if (err < 0)
    {
        std::cout << "连接服务器失败！" << std::endl;
        WSACleanup();
    }
    else
    {
        std::cout << "连接服务器成功！" << std::endl;
    }
}

void Client::sendMesg()
{
    char sendBuf[1024];
    char recvBuf[1024];
    int sendLen = 0;
    int recvLen = 0;
    while (true)
    {
        std::cout << "请输入要发送的消息：";
        std::cin >> sendBuf;

        //发送消息
        sendLen = send(m_sClientSocket, sendBuf, 1024, 0);
        if (sendLen < 0)
        {
            std::cout << "发送消息失败";
            break;
        }
        else
        {
            std::cout << "发送消息成功" << std::endl;;
        }
        memset(recvBuf, '\0', 1024);
        //接受消息
        recvLen = recv(m_sClientSocket, recvBuf, 1024, 0);
        if (recvLen < 0)
        {
            std::cout << "接受消息失败";
            break;
        }
        else
        {
            std::cout << "服务器端消息:" << recvBuf << std::endl;
        }
    }

    closesocket(m_sClientSocket);
    WSACleanup();
}

void Client::initSocket()
{
    WORD wClient = MAKEWORD(2, 2);
    WSADATA wcData;
    int err;
    err = WSAStartup(wClient, &wcData);
    if (err != 0)
    {
        std::cout << "客户端套接字库初始化失败" << std::endl;
    }
    else
    {
        std::cout << "客户端套接字初始化成功" << std::endl;
    }

    if (LOBYTE(wcData.wVersion) != 2 || HIBYTE(wcData.wHighVersion) != 2)
    {
        std::cout << "套接字库版本不符合" << std::endl;
    }
    else
    {
        std::cout << "套接字版本正确" << std::endl;
    }
}

Client::~Client()
{

}

int main()
{
    Client *client = new Client(8888);
    client->linkSever();
    client->sendMesg();
    return 0;
}