本项目使用C++实现具备多个客户端和服务器端即时通信聊天功能软件

一：项目内容
使用C++实现一个具备多客户端和一个服务器端即时通信功能的聊天软件。
本项目的目的是
学习在windows平台下，进行C++网络开发的基本概念：TCP/IP socket通信，多线程编程，文件配置读写和通信协议制定等；
二：需求分析
这个聊天室主要有两个程序：
1.服务端：能够接受新的客户连接，并将每个客户端发来的信息，转发给对应的目标客户端。
2.客户端：能够连接服务器，并向服务器发送消息，同时可以接收服务器发来的消息。
属于C/S模型。
三：抽象与细化
服务端类需要支持：
1.支持多个客户端接入，实现聊天室基本功能。
2.启动服务，建立监听端口等待客户端连接。
3.使用epoll机制实现并发，增加效率。
4.客户端连接时，发送欢迎消息，并存储连接记录。
5.客户端发送消息时，根据消息类型，广播给所有用户(群聊)或者指定用户(私聊)。
6.客户端请求退出时，对相应连接信息进行清理。
客户端类需要支持：
1.连接服务器。
2.支持用户输入消息，发送给服务端。
3.接受并显示服务端发来的消息。
4.退出连接。
四：C/S模型

五：涉及数据读写、转发等操作所以需要使用Windows 下IOCP模型：
　IOCP 全称I/O Completion Port，中文译为I/O完成端口。IOCP是一个异步I/O的Windows API，它可以高效地将I/O事件通知给应用程序，类似于Linux中的Epoll，详细信息请参考linux之epoll。
　I/O 完成端口可以充分利用 Windows 内核来进行 I/O 调度，相较于传统的Winsock模型，IOCP的优势主要体现在两方面：独特的异步I/O方式和优秀的线程调度机制。
　 IOCP模型通信机制，主要过程为：1、socket关联iocp；2、在socket上投递I/O请求；3、事件完成返回完成通知封包；4、工作线程在iocp上处理事件。IOCP的这种工作模式：程序只需要把事件投递出去，事件交给操作系统完成后，工作线程在完成端口上轮询处理。该模式充分利用了异步模式高速率输入输出的优势，能够有效提高程序的工作效率。完成端口可以抽象为一个公共消息队列，当用户请求到达时，完成端口把这些请求加入其抽象出的公共消息队列。这一过程与多个工作线程轮询消息队列并从中取出消息加以处理是并发操作。这种方式很好地实现了异步通信和负载均衡，因为它使几个线程“公平地”处理多客户端的I/O，并且线程空闲时会被挂起，不会占用CPU周期。
    IOCP模型充分利用Windows系统内核，可以实现仅用少量的几个线程来处理和多个client之间的所有通信，消除了无谓的线程上下文切换，最大限度的提高了网络通信的性能。

软件运行效果如下图：
客户端详细代码如下：

/****************************************************
 *
 *@Copyright (c) 2024, GhY, All rights reserved.
 *@文件    PublicDefine.h
 *@描述    公共数据结构定义
 *
 *@作者    GhY
 *@日期    2024年7月24日
 *@版本    v1.0.0
 *
 ****************************************************/
#pragma once
#include<stdio.h>
#include <iostream>
#include"winerror.h"
#define WIN32_LEAN_AND_MEAN
#include"Winsock2.h"



#define OutErr(a) std::cout << "error ：" << (a) << std::endl \
      << "出错代码："<< WSAGetLastError() << std::endl \
      << "出错文件："<< __FILE__ << std::endl  \
      << "出错行数："<< __LINE__ << std::endl \

#define OutMsg(a) std::cout << (a) << std::endl;



#define PORT            5050            // 监听端口
#define LOCAL_HOST      "127.0.0.1"     // 本地回路地址
#define DATA_BUFSIZE    8192

#define MAX_LISTEN_QUEUE    200

#define MAX_CONNECT      3000

#define MAX_DATA_LEN    2048        // 数据包长度

#define SEND_DATA_LEN    4096        // 发送数据包长度


/// 结构体定义
/*
 *@brief    用于IOCP的特定函数
 *@author   GhY
 *@date     2024/07/24
 */
typedef struct {
    OVERLAPPED Overlapped;
    WSABUF DataBuf;
    CHAR Buffer[DATA_BUFSIZE];
} PER_IO_OPERATION_DATA, *LPPER_IO_OPERATION_DATA;

/*
 *@brief    用于IOCP的特定结构
 *@author   GhY
 *@date     2024/07/24
 */
typedef struct _PER_HANDLE_DATA {
    SOCKET _socket;
    CHAR _ip[32];
    int _port;

    _PER_HANDLE_DATA()
    {
        _socket = NULL;
        memset(_ip, 0, 32);
        _port = -1;
    }
} PER_HANDLE_DATA, *LPPER_HANDLE_DATA;


#pragma pack(1)
/*
 *@brief    数据包头
 *@author   GhY
 *@date     2024/07/24
 */
typedef struct _DataHead {

    unsigned short  _type;      // 0=上传数据， 1=转发数据，2=请求数据
    unsigned int  _node;        // 客户端ID
    unsigned long   _time;

    _DataHead()
    {
        memset(this, 0, sizeof(_DataHead));
    }

} TcpHead, Udp_Head;

/*
 *@brief    数据包体
 *@author   GhY
 *@date     2024/07/24
 */
typedef struct _DataBody {
    char        _srcName[32];
    int         _length;
    char        _data[MAX_DATA_LEN];
    _DataBody()
    {
        memset(this, 0, sizeof(_DataBody));
    }

} TcpBody, UdpBody;

/*
 *@brief    发送数据
 *@author   GhY
 *@date     2024/07/24
 */
typedef struct _SendData {
    TcpHead _head;
    TcpBody _body;
} Tcp_SendData, Udp_SendData;

#pragma pack()


/*
 *@brief    socket连接管理
 *@author   GhY
 *@date     2024/07/24
 */
struct ClientManager {
    unsigned int _id;
    char _name[32];
    SOCKET _socket;
    char _addr[16];
    int _port;

    ClientManager()
    {
        memset(this, 0, sizeof(ClientManager));
    }

};

/*
 *@brief    通信消息
 *@author   GhY
 *@date     2024/07/24
 */
struct Message {
    unsigned int _sendId;
    char _send_name[32];
    unsigned int _receiverId;
    char _receiverName[32];
    char _data[MAX_DATA_LEN];

    Message()
    {
        memset(this, 0, sizeof(Message));
    }
};

/****************************************************
 *
 *@Copyright (c) 2024, GhY, All rights reserved.
 *@文件    application.h
 *@描述    app基类
 *
 *@作者    GhY
 *@日期    2024年7月24日
 *@版本    v1.0.0
 *
 ****************************************************/
#ifndef __APPLICATION_H__
#define __APPLICATION_H__

class application
{
public:
    application();
    virtual ~application();

    /*
     *@brief Do some initialize before application lanuch
     */
    virtual bool initinstance();

    /*
    *@brief Run application
    */
    virtual int run();

    /*
    *@brief Exit application
    */
    virtual bool exitinstance();

};

#endif // !__APPLICATION_H__

#include "application.h"

application::application()
{
}

application::~application()
{
}

bool application::initinstance()
{
    return true;
}

int application::run()
{
    if (initinstance()) {
        run();
    }

    return exitinstance();
}

bool application::exitinstance()
{
    return true;
}

/****************************************************
 *
 *@Copyright (c) 2024, GhY, All rights reserved.
 *@文件    client.h
 *@描述    客户端类声明
 *
 *@作者    GhY
 *@日期    2024年7月24日
 *@版本    v1.0.0
 *
 ****************************************************/
#ifndef  __CLIENT_H__
#define  __CLIENT_H__

#include<stdio.h>
#include<iostream>
#include "MySocket.h"
#include "MyReceive.h"
#include "application.h"
#include <string>
#include <vector>
#include <list>


class CCinData;


/*
 *@描述:    客户端类
 *@作者:    GhY
 *@日期:    2024/07/24
 *@历史:
 */
class CAppClient : public application, public sigslot::has_slots<>
{
public:
    CAppClient();

    ~CAppClient();

    /*
     *@brief    关联信号槽
     *@author   GhY
     *@date     2024/07/24
     */
    void InitSigslot();

    /*
     *@brief    初始化
     *@author   GhY
     *@date     2024/07/24
     */
    bool initinstance();

    /*
     *@brief    退出
     *@author   GhY
     *@date     2024/07/24
     */
    bool exitinstance();

    int run();
    /*
     *@desc       发送数据
     *@param:     sdata  待传输数据
     *@return     void
     *@author     GhY
     *@date       2024/07/24
     *@version    v1.0.0
     *@history:
     */
    void SendData(std::string* sdata);

public:
    MySocket* m_mysocket;

    std::list<std::string*> m_sendBufs;
    CCinData* m_sendData;
    bool m_exitFlag;   // 退出标志

protected:

private:
    MyReceive* m_myrev;
};

/*
 *@描述:    获取输入数据类
 *@作者:    GhY
 *@日期:    2024/07/24
 *@历史:
 */
class CCinData : public sigslot::has_slots<>
{
public:

    typedef sigslot::signal1<std::string* > SendDataEvent;

    SendDataEvent OnSendEvent;

public:

    CCinData(CAppClient* app);

    ~CCinData();

    void Run();

private:
    CAppClient* m_appClient;
    bool m_exitFlag;
};

#endif  //!__CLIENT_H__

/****************************************************
 *
 *@Copyright (c) 2024, GhY, All rights reserved.
 *@文件    client.cpp
 *@描述    客户端类实现
 *
 *@作者    GhY
 *@日期    2024年7月24日
 *@版本    v1.0.0
 *
 ****************************************************/
#include "client.h"



DWORD WINAPI ClientCinProcess(LPVOID lpParam)
{
    CAppClient* appclient = (CAppClient*)lpParam;
    if (!appclient) {
        return 1;
    }
    if (appclient->m_sendData) {
        appclient->m_sendData->Run();
    }
    return 0;
}


DWORD WINAPI RunSendBufProcess(LPVOID lpParam)
{
    CAppClient* appclient = (CAppClient*)lpParam;
    if (!appclient) {
        return 1;
    }
    while (true) {
        if (appclient->m_exitFlag) {
            break;
        }
        if (appclient->m_sendBufs.empty()) {
            Sleep(300);
            continue;
        }

        if (appclient->m_sendBufs.size() > 0) {
            std::string* strBuf = appclient->m_sendBufs.front();
            appclient->m_sendBufs.pop_front();
            if (appclient->m_mysocket && !strBuf->empty()) {
                appclient->m_mysocket->SendData(*strBuf);
                delete strBuf;
            }
        }
    }
    return 0;
}


CAppClient::CAppClient()
{
    m_exitFlag = false;
    m_mysocket = new MySocket();
    std::string sIp = g_ConfigPtr.getConfigValueWithKey("net", "ip");
    std::string sPort = g_ConfigPtr.getConfigValueWithKey("net", "port");
    int iPort = sPort.empty() ? PORT : atoi(sPort.c_str());

    m_mysocket->InitData(sIp, iPort);
    m_mysocket->ClientConnect();

    m_myrev = new MyReceive(m_mysocket);

    m_sendBufs.clear();

    m_sendData = new CCinData(this);
    InitSigslot();
}

CAppClient::~CAppClient()
{
    this->disconnect_all();

    if (m_myrev) {
        delete m_myrev;
        m_myrev = nullptr;
    }
    if (m_mysocket) {
        m_mysocket->Close();
        delete m_mysocket;
        m_mysocket = nullptr;
    }

    if (m_sendData) {
        delete m_sendData;
        m_sendData = nullptr;
    }
}

bool CAppClient::initinstance()
{
    return true;
}

bool CAppClient::exitinstance()
{
    return true;
}

int CAppClient::run()
{
    std::cout << "使用说明：输入 quit 退出程序" << std::endl;

    std::string currentName = g_ConfigPtr.getConfigValueWithKey("base", "name");
    if (currentName.empty()) {
        char nameT[64] = { 0 };
        std::cout << "请输入名字：";
        std::cin >> nameT;
        g_ConfigPtr.SetConfigValue("base", "name", nameT);
    } else {
        std::cout << "当前用户名：" << currentName.c_str() << std::endl;
    }

    static int nCnt = 0;
    char sendBuf[2000] = { 0 };

    int recvdata = 0;

    HANDLE hProcessIO = CreateThread(NULL, 0, ClientCinProcess, this, 0, NULL);
    if (hProcessIO) {
        CloseHandle(hProcessIO);
    }

    HANDLE hProcessIO2 = CreateThread(NULL, 0, RunSendBufProcess, this, 0, NULL);
    if (hProcessIO2) {
        CloseHandle(hProcessIO2);
    }

    while (true) {
        if (m_exitFlag) {
            break;
        }
        recvdata = m_mysocket->ReceiveData();
        if (recvdata == 0) {
            Sleep(500);
        } else {
            recvdata = 0;
        }
    }
    return 0;
}

void CAppClient::SendData(std::string* sdata)
{
    std::string* tmpdata = sdata;
    if (tmpdata->empty()) {
        return;
    }
    if (tmpdata->compare("quit") == 0) {
        m_exitFlag = true;
        m_mysocket->Close();
        delete tmpdata;
        return;
    }

    m_sendBufs.push_back(tmpdata);
}

void CAppClient::InitSigslot()
{
    if (m_sendData) {
        m_sendData->OnSendEvent.connect(this, &CAppClient::SendData);
    }
}

CCinData::CCinData(CAppClient* app)
    : m_appClient(app)
    , m_exitFlag(false)
{}

CCinData::~CCinData()
{
    m_exitFlag = true;
}

void CCinData::Run()
{
    std::cout << "please cin message: " << std::endl;
    std::string* sendTest = new std::string("上线");
    OnSendEvent.emit(sendTest);

    while (true) {
        if (m_exitFlag) {
            break;
        }
        std::string* sendBuf = new std::string();
        //std::cin >> sendBuf;
        getline(std::cin, *sendBuf);
        if (!sendBuf->empty() && sendBuf->compare("quit") == 0) {
            m_exitFlag = true;
        }
        if (sendBuf->size() > 0) {
            OnSendEvent.emit(sendBuf);
        } else {
            Sleep(500);
        }
    }
}

/****************************************************
 *
 *@Copyright (c) 2024, GhY, All rights reserved.
 *@文件    MyReceive.h
 *@描述    处理数据类声明
 *
 *@作者    GhY
 *@日期    2024年7月24日
 *@版本    v1.0.0
 *
 ****************************************************/
#ifndef  __MYRECEIVE_H__
#define __MYRECEIVE_H__
#include "MySocket.h"


/*
 *@描述:    接收数据处理类
 *@作者:    GhY
 *@日期:    2024/07/24
 *@历史:
 */
class MyReceive : public sigslot::has_slots<>
{
public:
    MyReceive(MySocket* s);
    ~MyReceive();

    /*
     *@brief    关联信号槽
     *@author   GhY
     *@date     2024/07/24
     */
    void InitSigslot();

    /*
     *@desc       接收数据
     *@param:     sdata  待接收数据
     *@return     void
     *@author     GhY
     *@date       2024/07/24
     *@version    v1.0.0
     *@history:
     */
    void ReceiveData(Tcp_SendData* sdata);

private:
    MySocket* m_mysocket;

};

#endif  //!__MYRECEIVE_H__

/****************************************************
 *
 *@Copyright (c) 2024, GhY, All rights reserved.
 *@文件    MyReceive.cpp
 *@描述    处理数据类实现
 *
 *@作者    GhY
 *@日期    2024年7月24日
 *@版本    v1.0.0
 *
 ****************************************************/
#include "MyReceive.h"

MyReceive::MyReceive(MySocket* s)
    : m_mysocket(s)
{
    InitSigslot();
}

MyReceive::~MyReceive()
{
    if (m_mysocket) {
        m_mysocket->disconnect_all();
    }
}

void MyReceive::InitSigslot()
{
    if (m_mysocket) {
        m_mysocket->OnSelectEvent.connect(this, &MyReceive::ReceiveData);
    }
}


void MyReceive::ReceiveData(Tcp_SendData* sdata)
{
    if (!sdata) {
        return;
    }
    do {
        if (sdata->_head._type == 2) {
            std::string tmp = sdata->_body._data;
            g_ConfigPtr.SetConfigValue("base", "id", tmp);
        } else {
            std::string tmpName = sdata->_body._srcName;
            std::string tmp = sdata->_body._data;
            std::cout << "send: " << tmpName.c_str() << " -- message:  " << tmp.c_str() << std::endl;
        }
    } while (0);

}

注意：

文章中依赖的文件（.h，.cpp）请参见本专栏其他文章。

源代码下载地址：源代码