进程间UDP通信(C++)

服务端：
#include "stdafx.h"
#include <iostream>
#include <stdlib.h>
#include <stdio.h>
#include <Winsock2.h>
#include<windows.h>
#pragma comment(lib, "WS2_32.lib")

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

    void sendMesg();

private:
    void initSocketLib();
    
private:
    SOCKET m_sSeverSocket;
    sockaddr_in m_SeverAddr;
};

SeverUDP::SeverUDP(int port)
{
    initSocketLib();

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

    //设置套接字属性
    m_SeverAddr.sin_addr.S_un.S_addr = htonl(INADDR_ANY);
    m_SeverAddr.sin_family = AF_INET;
    m_SeverAddr.sin_port = htons(port);

    //绑定套接字
    int err = bind(m_sSeverSocket, (SOCKADDR*)&m_SeverAddr, sizeof(SOCKADDR));
    if (err < 0)
    {
        std::cout << "套接字绑定失败" << std::endl;
    }
    else
    {
        std::cout << "套接字绑定成功" << std::endl;
    }

}

SeverUDP::~SeverUDP()
{
    closesocket(m_sSeverSocket);
    WSACleanup();
}

void SeverUDP::sendMesg()
{
    sockaddr_in clientAddr;

    int len = sizeof(SOCKADDR);

    //接受客户端消息字符数组
    char clientBuf[1024];

    //服务端消息字符数组
    char recvBuf[1024];

    //组合收到的消息字符数组
    char tempBuf[1024];
    while (true)
    {

        //接受客户端消息
        recvfrom(m_sSeverSocket, clientBuf, 1024,0, (SOCKADDR*)&clientAddr, &len);
        if (clientBuf[0] == 'q')
        {
            //接受到退出字符，通知客户端
            sendto(m_sSeverSocket, "q", strlen("q") + 1, 0, (SOCKADDR*)&clientAddr, len);
            std::cout << "客户端已退出" << std::endl;
            break;
        }

        //组合终端显示字符串
        sprintf_s(tempBuf, "%s 消息：%s", inet_ntoa(clientAddr.sin_addr), clientBuf);
        std::cout << tempBuf << std::endl;
       
        std::cout << "请输入回复消息：";
        std::cin >> recvBuf;
        //将输入的消息发送出去
        int result = sendto(m_sSeverSocket, recvBuf, 1024, 0, (SOCKADDR*)&clientAddr, len);
        if (result < 0)
        {
            std::cout << "发送失败" << std::endl;
        }
        else
        {
            std::cout << "发送成功" << std::endl;
        }
    }
    //关闭套接字
    closesocket(m_sSeverSocket);
    WSACleanup();
}

void SeverUDP::initSocketLib()
{
    WORD wudp;
    WSADATA wudpData;
    int err;
    wudp = MAKEWORD(2, 0);
    //初始化套接字库
    err = WSAStartup(wudp, &wudpData);
    if (err != 0)
    {
        std::cout << "初始化套接字库失败" << std::endl;
        return;
    }
    else
    {
        std::cout << "初始化套接字库成功" << std::endl;
    }
    //比较版本是否正确
    if (LOBYTE(wudpData.wVersion != 2) || HIBYTE(wudpData.wHighVersion != 1))
    {
        std::cout << "套接字版本不相等" << std::endl;
        WSACleanup();
    }
    else
    {
        std::cout << "套接字版本相等"<<std::endl;
    }
}

int main()
{
    SeverUDP *severUDP = new SeverUDP(6886);
    severUDP->sendMesg();
    return 0;
}

客户端：
#include "stdafx.h"
#include <iostream>
#include <Winsock2.h>
#include <stdio.h>
#include<windows.h>
#pragma comment(lib, "WS2_32.lib")
class ClientUDP
{
public:
    ClientUDP(int port);
    ~ClientUDP();

private:
    void initSocketLib();
private:
    SOCKET m_sClientSocket;
    sockaddr_in m_clientAddr;
};

ClientUDP::ClientUDP(int port)
{
    //初始化套接字库
    initSocketLib();
    //创建套接字
    m_sClientSocket = socket(AF_INET, SOCK_DGRAM, 0);

    //设置套接字属性
    m_clientAddr.sin_family = AF_INET;
    m_clientAddr.sin_addr.S_un.S_addr = inet_addr("127.0.0.1");
    m_clientAddr.sin_port = htons(port);


    int len = sizeof(SOCKADDR);

    //接受消息数组
    char recvBuf[1024];

    //发送消息数组
    char sendBuf[1024];

    //接受到消息组合字符串数组
    char tempBuf[1024];

    while (true)
    {
        std::cout << "请输入发送的消息:";
        std::cin >> sendBuf;
        //将输入的消息发送出去
        sendto(m_sClientSocket, sendBuf, strlen(sendBuf)+1, 0, (SOCKADDR*)&m_clientAddr, len);
       
        //接受服务端发来的消息
        recvfrom(m_sClientSocket, recvBuf, 1024, 0, (SOCKADDR*)&m_clientAddr, &len);
        if (recvBuf[0] == 'q')
        {
            //回复收到退出的消息
            sendto(m_sClientSocket, "q", strlen("q") + 1, 0, (SOCKADDR*)&m_clientAddr, len);
            std::cout << "服务器已退出";
            break;
        }

       //组合显示数组
        sprintf_s(tempBuf, "%s 消息 %s", inet_ntoa(m_clientAddr.sin_addr), recvBuf);
        std::cout << tempBuf << std::endl;
        
    }
    //关闭套接字
    closesocket(m_sClientSocket);
    WSACleanup();
}

ClientUDP::~ClientUDP()
{
    closesocket(m_sClientSocket);
    WSACleanup();
}

void ClientUDP::initSocketLib()
{
    WORD client;
    WSADATA clientData;
    int err;

    client = MAKEWORD(2, 0);
    err = WSAStartup(client, &clientData);
    if (err != 0)
    {
        std::cout << "套接字初始化失败" << std::endl;
        return;
    }
    else
    {
        std::cout << "套接字初始化成功" << std::endl;
    }

    if (LOBYTE (clientData.wVersion != 2) || HIBYTE(clientData.wHighVersion != 1))
    {
        std::cout << "套接字库版本不对" << std::endl;
        WSACleanup();
        return;
    }
    else
    {
        std::cout << "套接字版本正确" << std::endl;
    }
}

int main()
{
    ClientUDP* client = new ClientUDP(6886);
    return 0;
}