C++ 代码实现局域网即时通信功能 （windows 系统 客户端）

已于 2024-07-24 19:02:45 修改
阅读量124 收藏
点赞数 5
分类专栏： C++ 高级进阶 文章标签： c++ windows visual studio tcp/ip
于 2024-07-24 18:23:57 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45310411/article/details/140667010
版权

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

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

源代码下载地址：源代码

奋斗羊羊
关注
  • 5
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
C++ 实现局域网内即时通信服务端功能 （windows 系统）
weixin_45310411的博客
07-24 1
C++ 实现局域网内即时通信服务端功能 （windows 系统）
基于C++Qt实现局域网通讯软件[2024-04-22]
程序设计
04-22 788
8]李淑梅,王志彬.Socket在局域网聊天系统中的应用[J].吉林师范大学学报(自然科学版), 2014,35(01):71-73.DOI:10.16862/j.cnki.issn1674-3873.2014.01.019.4、类设计：设计并实现MsgBuilder类、HHTcpSocket类、ChatWidget类、ChatItem类、TcpServerForServer类和NetWorkThread类等关键类，确保系统的可扩展性和可维护性。[10] 基于QT的串口通信程序设计[J]. 郑忠楷;
基于C++的即时通信软件设计
毕业作品网站
09-05 8837
主界面对话框：包括消息发送编辑框、消息接收显示区、好友在线情况显示区、发送按钮、以及登陆按钮；设计一个基于 LAN 的即时通信软件，实现在局域网下可靠的、稳定的即时通信功能以及其从属的附加功能。结合《计算机网络》课程所学的知识以及查阅相应的资料完成相应的设计内容， 且需要保证设计的质量以及程序的可靠性和稳定性。1 . 2 . 3 客 户 端 、 服 务 器 设 计 ： 1。3 . 1 . 1 登 陆 、 注 册 对 话 框 2。2 . 3 . 2 服 务 器 端 设 计 ： 1。
C++ 实现即时通信软件（直接运行）
mitongxue的博客
04-26 6604
题目 由于本学期上了网络编程课程，老师要求写使用Socke实现网络编程。于是参考 C++多线程实现即时通信软件 写出了简单版本的没有界面的即时通信软件。 软件：VS 直接上代码，需要讲解原理的，可以参考 C++多线程实现即时通信软件 服务器端 //TcpServer_plus.exe #include<stdio.h> #include <Winsock2.h> #include<WS2tcpip.h> #pragma comment(lib,"ws2_32.lib")
局域网即时通信程序源码.rar
04-05
局域网即时通信程序是一种在有限的网络范围内（如办公室、校园或家庭）实现快速、高效通信的应用。这种程序通常采用C++等编程语言开发，因为它提供了底层控制和高性能的优势。下面将详细介绍局域网即时通信程序源码...
基于Qt的局域网即时通信系统（聊天软件demo）
08-03
【基于Qt的局域网即时通信系统】是一个利用Qt库构建的本地网络通信软件示例，主要用于演示如何在局域网环境中实现简单的即时聊天功能。这个项目采用了UDP（用户数据报协议）进行实时的消息传递，而文件传输部分则...
基于Qt的局域网即时通信系统 .doc
03-26
综上所述，基于Qt的局域网即时通信系统是一个集成了多种功能的实时通讯平台，利用Qt的强大功能，实现了丰富的用户交互和稳定的网络通信。通过模块化的设计，系统具备良好的可扩展性和维护性，能满足不同用户在局域网...
基于P2P的局域网即时通信系统（VC）
01-14
【基于P2P的局域网即时通信系统（VC）】是一种利用对等网络技术实现的局域网内部通信工具，旨在提供一个简单、高效且可靠的通信环境。在这个系统中，每个参与者既是服务器也是客户端，这意味着每个用户都可以接收和...
C++二叉搜索树
Jk_Mr的博客
07-20 1090
树结构是一种重要的数据结构。树是一种非线性的数据结构，它是由n（n>=0）个有限结点组成一个具有层次关系的集合。把它叫做树是因为它看起来像一棵倒挂的树，也就是说它是根朝上，而叶朝下的。
C++ 继承篇
2301_79201049的博客
07-18 697
必须对继承而来的成员进行初始化直接通过初始化列表或者赋值的方式进行初始化调用父类构造函数进行初始化
【C++】操作符“new”和“delete”（创建和销毁对象）
qq_65596720的博客
07-19 387
由于C++引入了类的概念所以创建空间和销毁空间变得复杂，使用malloc和free会更加复杂，所以C++引入了new和delete来简化代码。
商品信息管理系统(C语言)
zeyeqianli的博客
07-22 231
该案例使用了C语言中最具特色的结构体，将每个商品的所有信息存在结构体中，并且定义一个结构体类型的数组保存所有商品的信息，并且按照模块化的编程思想，将要实现的每个功能编写成独立的函数，这样即方便阅读同时也方便差错修改。该系统的主要功能如下：(1) 登录系统。(2) 创建商品信息。(3) 打印商品信息。(4) 查询商品信息。(5) 修改商品信息。(6) 删除商品信息。(7) 商品价格排名显示。(8) 退出系统。
C++笔记3：基类指针delete子类对象的内存泄漏问题
subtitle_的博客
07-21 223
C++笔记3：基类指针delete子类对象的内存泄漏问题
2024年华为OD机试真题-虚拟游戏理财-C++-OD统一考试（C卷D卷）
面试高手的博客
07-21 9717
现有一家Bank，它提供有若干理财产品m，风险及投资回报不同，你有N（元）进行投资，能接受的总风险值为X。第一行：产品数(取值范围[1, 20])，总投资额(整数，取值范围[1, 10000])，可接受的总风险(整数，取值范围[1, 200])投资第二项30个单位，第四项40个单位，总的投资风险为两项相加为4+6=10。第四行：最大投资额度序列，输入为整数，取值范围[1,10000]第二行：产品投资回报率序列，输入为整数，取值范围[1,60]第三行：产品风险值序列，输入为整数，取值范围[1,100]
C语言 打印菱形的程序（Program to print the Diamond Shape）
csdn_aspnet的专栏
07-22 1333
O(n*n)，因为我们正在遍历网格的行和列来打印空格 ' '和星号 '*'。给定一个数字n ，编写一个程序来打印一个有2n行的菱形。O(1)，不使用额外空间。
【C++修炼之路 第三章：内存管理】new & delete、operator new & operator delete
唯有忍受别人不能忍受的，才能享受别人不能享受的
07-18 717
【含常见面试题】new & delete 的概念与用法 + 定位new表达式 + malloc/free 和 new/delete 的区别
学懂C语言（二十一）：深入理解C语言中的函数指针和回调函数
最新发布
martian665的专栏
07-23 156
学懂C语言：C语言中的函数指针和回调函数详解
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

奋斗羊羊

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值