面向select网络编程转化为面向对象

最新推荐文章于 2024-08-02 16:22:25 发布
最新推荐文章于 2024-08-02 16:22:25 发布
阅读量75 收藏
点赞数
分类专栏： 网络 文章标签： 网络 socket
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/holidaywu/article/details/105874532
版权

数据包

#ifndef _MessageHeader_hpp_
#define _MessageHeader_hpp_

enum CMD{

    CMD_LOGIN,
    CMD_LOGIN_RESULT,
    CMD_LOGOUT,
    CMD_LOGOUT_RESULT,
    CMD_NEW_USER_JOIN,
    CMD_ERROR
};

//文件头
struct DataHeader{

    short cmd;
    short dataLength;

};
//登录
struct Login :public DataHeader
{
    Login(){
        dataLength = sizeof(Login);
        cmd = CMD_LOGIN;
    }

    char username[32];
    char password[32];
};
//登录结果
struct LoginResult :public DataHeader {

    LoginResult(){
        dataLength = sizeof(LoginResult);
        cmd = CMD_LOGIN_RESULT;
        result = 1;
    }
    int result;

};
//退出
struct Logout :public DataHeader{

    Logout(){
        dataLength = sizeof(Logout);
        cmd = CMD_LOGOUT;
    }
    char userName[32];
};
//退出结果
struct LogoutResult :public DataHeader{

    LogoutResult(){
        dataLength = sizeof(LogoutResult);
        cmd = CMD_LOGOUT_RESULT;
        result = 1;
    }
    int result;
    char data[1024];

};
//新用户加入
struct NewUserJoin :public DataHeader{

    NewUserJoin(){
        dataLength = sizeof(NewUserJoin);
        cmd = CMD_NEW_USER_JOIN;
        scok = 0;
    }
    int scok;

};
#endif

 

client端


#ifndef _easyClient_hpp_
#define _easyClient_hpp_

#define WIN32_LEAN_AND_MEAN
#define _CRT_SECURE_NO_WARNINGS
#include<windows.h>
#include<WinSock2.h>
#pragma comment(lib,"ws2_32.lib")//动态链接库
#include<iostream>
#include<stdio.h>
#include<thread>
#include "MH.h"


class easyClient
{
    SOCKET sock;
public:
    easyClient()
    {
        sock = INVALID_SOCKET;
    }
    //虚析构函数
    virtual ~easyClient()
    {
        Close();
    }
    //初始化socket
    void InitSocket(){
        //启动winsock2.x环境
        WORD ver = MAKEWORD(2, 2);
        WSADATA dat;
        WSAStartup(ver, &dat);
        if (sock != INVALID_SOCKET){
            printf("<SOCKET=%d>关闭旧连接", sock);
            Close();
        }
        //1、建立socket
        sock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);


    }

    int Connect(char* ip, unsigned short port){
        if (sock == INVALID_SOCKET){
            InitSocket();
        }

        // 2、连接服务器
        sockaddr_in _sin = {};
        _sin.sin_family = AF_INET;
        _sin.sin_port = htons(port);//host to net unsigned short
        _sin.sin_addr.S_un.S_addr = inet_addr(ip);
        int ret = connect(sock, (sockaddr*)&_sin, sizeof(sockaddr_in));
        if (SOCKET_ERROR == ret)
            std::printf("绑定网络端口失败。。。");
        return ret;
    }

    //关闭socket
    void Close(){

        //关闭winsock 2.x环境
        if (sock != INVALID_SOCKET){
            closesocket(sock);
            WSACleanup();
            sock = INVALID_SOCKET;
        }

    }

    //处理网络消息
    bool  OnRun(){

        if (isRun()){
            fd_set fdReader;
            FD_ZERO(&fdReader);
            FD_SET(sock, &fdReader);
            timeval t = { 1, 0 };

            int ret = select(sock, &fdReader, 0, 0, NULL);
            if (ret < 0){
                std::printf("<SOCKET=%d>select 任务结束1\n", sock);
                return false;
            }

            if (FD_ISSET(sock, &fdReader)){

                FD_CLR(sock, &fdReader);

                if (-1 == RecvData(sock)){
                    std::printf("<SOCKET=%d>select 任务结束2\n", sock);
                    return false;
                }
            }
            return true;
        }
        return false;

    }

    //接收消息，处理粘包
    int RecvData(SOCKET _cSocket){

        char szRecv[1024] = {};
        //5、接收客户端请求数据

        int nLen = recv(_cSocket, szRecv, sizeof(DataHeader), 0);

        DataHeader* header = (DataHeader*)szRecv;
        if (nLen <= 0){
            std::printf("与服务器断开连接，任务结束。\n", _cSocket);
            return -1;
        }
        recv(_cSocket, szRecv + sizeof(DataHeader), header->dataLength - sizeof(DataHeader), 0);

        OnNetMag(_cSocket, header);

        return 0;

    }

    //响应网络消息
    void OnNetMag(SOCKET _cSocket, DataHeader* header){
        //6、处理请求

        switch (header->cmd){
        case CMD_LOGIN_RESULT: {

                                   LoginResult* login = (LoginResult*)header;
                                   std::printf("收到服务器=%d消息：CMD_LOGIN_RESULT，数据长度:%d  \n", _cSocket, header->dataLength);

 

        } break;
        case CMD_LOGOUT_RESULT:{

                                   LogoutResult* logout = (LogoutResult*)header;
                                   std::printf("收到服务器=%d消息：CMD_LOGOUT_RESULT，数据长度:%d  \n", _cSocket, header->dataLength);

 

        }break;
        case CMD_NEW_USER_JOIN:{

                                   NewUserJoin* userjoin = (NewUserJoin*)header;
                                   std::printf("收到服务器=%d消息：CMD__NEW_USER_JOIN,新用户加入\n", _cSocket);


        } break;

        }
        std::printf("发送成功\n");

    }
    //发送网络消息
    int SendData(DataHeader* header){
        if (isRun() && header){
            return send(sock, (const char*)header, header->dataLength, 0);
        }
        return INVALID_SOCKET;
    }


    //是否工作中
    bool isRun(){
        return sock != INVALID_SOCKET;
    }
private:

 

};
#endif

client端的main.cpp

主函数:

 

#include<iostream>
#include<stdio.h>
#include<thread>
#include "client.h"
#include"MH.h"
using namespace std;

 

void cmdThread(easyClient* client)
{
    while (true){

        char cmdBuf[256] = {};
        scanf("%s", cmdBuf);
        if (0 == strcmp(cmdBuf, "exit")){
            client->Close();
            std::printf("退出thread线程\n");
            return;
        }
        else if (0 == strcmp(cmdBuf, "login")){
            Login login;
            strcpy(login.username, "wwy");
            strcpy(login.password, "123");
            client->SendData(&login);
        }
        else if (0 == strcmp(cmdBuf, "logout")){
            Logout logout;
            strcpy(logout.userName, "wwy");
            client->SendData(&logout);
        }
        else{
            printf("不支持的命令\n");
        }
    }

 

}

int main(){

    easyClient client;
    client.Connect("127.0.0.1", 4567);

    //启动线程

    thread t1(cmdThread, &client);
    t1.detach();


    while (client.isRun()){
        client.OnRun();


    }
    client.Close();

 

    std::printf("已退出\n");
    std::system("pause");

    return 0;
}

 

 

server端

 

#ifndef _servers_hpp_
#define _servers_hpp_

#define WIN32_LEAN_AND_MEAN
#define _CRT_SECURE_NO_WARNINGS
#include<windows.h>
#include<WinSock2.h>
#include<iostream>
#include<vector>
#include"MH.h"
#pragma comment(lib,"ws2_32.lib")//动态链接库
//可以在属性的链接库中添加
using namespace std;


class servers{

public:
    servers(){
        sock = INVALID_SOCKET;
    }

    virtual ~servers(){

        Close();
    }

    //初始化Socket
    SOCKET InitSocket(){

        //启动winsock2.x环境
        WORD ver = MAKEWORD(2, 2);
        WSADATA dat;
        WSAStartup(ver, &dat);
        if (sock != INVALID_SOCKET){
            printf("<SOCKET=%d>关闭旧连接", sock);
            Close();
        }
        //1、建立socket
         sock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);

        return sock;
    }

    //绑定端口号
    int Bind(const char* ip, unsigned short port){

        if (sock == INVALID_SOCKET){
            InitSocket();
        }
        // 2、绑定网络端口
        sockaddr_in _sin = {};
        _sin.sin_family = AF_INET;
        _sin.sin_port = htons(port);//host to net unsigned short
        _sin.sin_addr.S_un.S_addr = inet_addr(ip);

        int ret = bind(sock, (sockaddr*)&_sin, sizeof(sockaddr_in));

        if (SOCKET_ERROR == ret)
            printf("绑定网络端口失败。。。");

        return ret;

 

    }


    //监听端口号
    int Listen(int n){

        //3、listen 监听端口
        int ret = listen(sock, n);
        if (SOCKET_ERROR == ret)
            printf("<SOCKET=%d>监听网络端口失败。。。", sock);

        return ret;
    }

 

    //接收客户端连接
    SOCKET Accept(){
        //4、accept 等待客户端连接
        sockaddr_in clientAddr = {};
        int nAddrlen = sizeof(sockaddr_in);
        SOCKET _cSocket = INVALID_SOCKET;

        _cSocket = accept(sock, (sockaddr*)&clientAddr, &nAddrlen);

        if (INVALID_SOCKET == _cSocket){
            printf("<SOCKET=%d>错误，接收到无效客户端。。。\n", (int)_cSocket);
        }
        else
        {
            NewUserJoin userjoin;
            SendDataToAll(&userjoin);
            g_clients.push_back(_cSocket);

            printf("新客户端加入：socket=%d,IP=%s\n", (int)_cSocket, inet_ntoa(clientAddr.sin_addr));

        }
        return _cSocket;
    }

    //关闭socket
    void Close(){

        //关闭winsock 2.x环境
        if (sock != INVALID_SOCKET){
            for (size_t n = g_clients.size() - 1; n >= 0; n--){
                closesocket(g_clients[n]);
            }

            // 7、关闭服务端套接字
            closesocket(sock);
            WSACleanup();
            sock = INVALID_SOCKET;
        }

    }


    //处理网络消息
    bool OnRun(){
        if (isRun()){

            fd_set fdRead;
            fd_set fdWrite;
            fd_set fdExp;

            //清理集合
            FD_ZERO(&fdRead);
            FD_ZERO(&fdWrite);
            FD_ZERO(&fdExp);

            //加入集合
            FD_SET(sock, &fdRead);
            FD_SET(sock, &fdWrite);
            FD_SET(sock, &fdExp);

            SOCKET maxSock = sock;
            for (int n = (int)g_clients.size() - 1; n >= 0; n--){
                //判断集合是否在集合中
                FD_SET(g_clients[n], &fdRead);
                if (maxSock < g_clients[n])
                    maxSock = g_clients[n];
            }
            timeval t = { 1, 0 };
            int ret = select(sock + 1, &fdRead, &fdWrite, &fdExp, &t);
            if (ret < 0){
                printf("select 客户端已退出。。。\n");
                Close();
                return false;
            }

            if (FD_ISSET(sock, &fdRead)){

                FD_CLR(sock, &fdRead);
                Accept();
            }

 

            for (int n = (int)g_clients.size() - 1; n >= 0; n--)
            {
                if (FD_ISSET(g_clients[n], &fdRead)){
                    {
                        if (-1 == RecvData(fdRead.fd_array[n]))
                        {
                            auto iter = find(g_clients.begin(), g_clients.end(), fdRead.fd_array[n]);
                        
                            //auto iter = g_clients.begin() + 1;
                            if (iter != g_clients.end())
                            {
                                g_clients.erase(iter);
                            }
                        }
                    }
                }

            }
            return true;
        }

        else{
            return false;
        }
    }

    //发送指定socket网络消息
    int SendData(SOCKET _cSocket, DataHeader* header){
        if (isRun() && header){
            return send(_cSocket, (const char*)header, header->dataLength, 0);
        }
        return INVALID_SOCKET;
    }

    //发送指定socket网络消息
    void SendDataToAll(DataHeader* header){
        if (isRun() && header){
            for (int n = (int)g_clients.size() - 1; n >= 0; n--){
                SendData(g_clients[n], header);
            }
        }

    }

    //是否工作中
    bool isRun(){
        return sock != INVALID_SOCKET;
    }
    //接收消息，处理粘包
    int RecvData(SOCKET  _cSocket){
        char szRecv[1024] = {};
        //5、接收客户端请求数据

        int nLen = recv(_cSocket, szRecv, sizeof(DataHeader), 0);
        DataHeader* header = (DataHeader*)szRecv;
        if (nLen <= 0){
            std::printf("客户端<SOCKET=%d>已退出\n", _cSocket);
            return -1;
        }
        std::printf("收到客户端的信息为：%d ,数据长度为%d\n", header->cmd, header->dataLength);
        recv(_cSocket, szRecv + sizeof(DataHeader), header->dataLength - sizeof(DataHeader), 0);
        OnNetMag(_cSocket, header);
        return 1;

    }

    //响应网络消息
    virtual void OnNetMag(SOCKET _cSocket, DataHeader* header){

        switch (header->cmd){
        case CMD_LOGIN: {


                            Login* login = (Login*)header;
                            std::printf("收到<SOCKET=%d>命令：CMD_LOGIN，数据长度:%d ,username:%s password:%s \n", _cSocket, login->dataLength, login->username, login->password);

                            std::printf("姓名为：%s上线了。。。\n", login->username);

                            LoginResult ret;
                            SendData(_cSocket, (DataHeader*)&ret);

        }break;

        case CMD_LOGOUT:{


                            Logout* logout = (Logout*)header;
                            std::printf("收到<SOCKET=%d>命令：CMD_LOGOUT，数据长度:%d  username:%s \n", _cSocket, logout->dataLength, logout->userName);

                            std::printf("姓名为：%s 已下线。。。\n", logout->userName);

                            LogoutResult ret;
                            SendData(_cSocket, (DataHeader*)&ret);


        }
            break;

        default:
        {    DataHeader header ;
        SendData(_cSocket, &header);
        }
            break;

        }

 

        std::printf("发送成功\n");
    }

    
private:
    vector<SOCKET> g_clients;
    SOCKET sock;

};

 

#endif

 

server端main.cpp文件

主函数：


#include<iostream>
#include"server.h"


int main(){

    servers server;
    server.InitSocket();
    server.Bind("127.0.0.1", 4567);
    server.Listen(5);


    while (server.isRun()){

        server.OnRun();

    }
    server.Close();

 

    printf("已退出，任务结束");
    system("pause");
    return 0;
}

 

 

 

 

holidaywu
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++高并发网络架构与实现——第四篇
双鱼座boyy的博客
12-02 1844
学会使用C++实现从1个用户连接到10000个用户链接，从每秒1个用户/1个数据包,到1万用户/1百万个数据包，最终实现高并发服务器
面向对象的php操作mssql类.zip
07-11
首先，我们要理解面向对象编程（Object-Oriented Programming, OOP）的基本概念。OOP是编程范式的一种，它以“对象”为核心，对象包含了数据（属性）和操作数据的方法（函数）。在PHP中，我们可以定义类来创建对象，...
项目(百万并发网络通信架构)6.2---将服务端端封装为class
董哥的黑板报
04-07 720
一、概述 在前面的文章中，客户端的代码都是以面向过程的形式展现，本文将之前客户端的代码封装为一个class
select网络通信02
holidaywu的博客
09-23 93
client02 #define WIN32_LEAN_AND_MEAN #define _CRT_SECURE_NO_WARNINGS #include<windows.h> #include<WinSock2.h> #include<iostream> #include<stdio.h> using namespace std; #prag...
Server - Select网络模型
莫忘输赢的博客
08-04 242
Select网络模型 利用select网络模型可以很好的优化之前写的简单的tcp程序。废话少说，直接步入正题： typedef struct fd_set { u_int fd_count; // 有多少个socket SOCKET fd_array[FD_SETSIZE]; // 客户端socket数组，FD_SETSIZE为64 ...
fd_set 类型用法
sin0803的专栏
07-01 2231
define FD_SETSIZE      1024 typedef unsigned long   fd_mask; #define NBBY    8               /* number of bits in a byte */ #define NFDBITS (sizeof(fd_mask) * NBBY)        /* bits per mask */
一个php面向对象数据库操作类库
04-28
在PHP编程中，面向对象（Object-Oriented Programming, OOP）是一种常用的设计模式，它使得代码更加结构化，易于维护和扩展。本篇将详细讲解一个PHP面向对象的数据库操作类库及其核心知识点。 首先，面向对象的...
Web服务器和浏览器的设计.zip_WEB服务器实验_stretcheyk_web服务器_浏览器_网络编程
09-24
通过阅读和分析源代码，我们可以学习到C++的面向对象编程、模板、异常处理等技术。 5. **HTTP与HTTPS**：实验可能包括对HTTP和HTTPS协议的深入理解，包括加密、身份验证等安全特性。HTTP/2和QUIC等现代协议的特性也...
Visual C++网络高级编程(附实例代码)
07-04
《Visual C++网络高级编程...它不仅讲解了网络编程的基本原理，还提供了实践操作的指导，帮助读者将理论知识转化为实际应用。通过学习这本书，读者将能够构建出高效、稳定的网络应用程序，满足各种复杂的网络通信需求。
面向智能设备的语音交互编程语言-陈奇.pdf
12-19
【面向智能设备的语音交互编程语言】是一种专为解决智能设备上语音交互问题而设计的领域特定语言，称为VSL（Voice Specific Language）。VSL的出现旨在降低开发和维护成本，提高可复用性，并实现不同场景下的交互...
Server - 严重错误记录（代码对比）
莫忘输赢的博客
08-05 148
一、代码对比 ​ //接收头部代码 - 正确代码 char szRecv[4096] = {}; int nLen = (int)recv(_cSock, szRecv, sizeof(DataHeader), 0); DataHeader* header = (DataHeader*)szRecv; //接收头部代码 - 错误代码 DataHeader recvDH; int nLen = ...
Linux C select函数详解
wwxy1995的博客
03-30 567
在Linux环境下，select函数如下 #include <sys/select.h> #include <sys/time.h> int select(int maxfdp1,fd_set *readset,fd_set *writeset,fd_set *exceptset,const struct timeval *timeout) //返回值：就绪描述符...
解决客户端、服务端粘包问题
qq_35750655的博客
06-08 332
EasyTcpClient.hpp #ifndef _EasyTcpClient_hpp_ #define _EasyTcpClient_hpp_ #ifdef _WIN32 #define WIN32_LEAN_AND_MEAN #include<windows.h> #include<WinSock2.h> #pragma comment(lib,"ws2_32.lib") #else #include<unistd.h> //uni std #include&.
TCP 粘包问题以及解决
wwxy1995的博客
07-08 187
如果发送端数据发送过块，接收端的数据接受过慢，接受端TCP内部的缓存区域会溢出，无法再发送数据，造成网络阻塞。 所以每次要尽可能的把缓冲区数据读出来，而不是每次读一条消息头。 因此要在应用层设置第二缓冲区，再从第二缓冲区读数据，拆分包 完整图片说明 //缓冲区 char _szRecv[RECV_BUFF_SZIE] = {}; //接收数据 处理粘包 拆分包 ...
未知攻焉知防：从攻击者视角看网络安全的“攻守之道”
科技云报道
08-01 405
基于独特的“动态安全+AI”技术思想，瑞数信息综合运用自动化攻击保护、0day防护、多源低频防护、多维度分层分级对抗等多种安全防护策略和手段，还推出瑞数WAAP超融合平台，支持WAF、Bots防护、0day攻击防护、应用DDoS防护、API安全防护等多项安全产品单独或联合部署，能够覆盖Web、移动App、H5、API及IoT全应用渠道，提供多层级的联动防御机制，令企业在各类复杂的环境中，都可以轻松实现应用安全一体化防御。其次，由于供应链数量众多，类型错综复杂，导致安全难以做到统一管理，供应链风险与日俱增。
网安科班精选！爱荷华大学教授的网络安全零基础入门教程！
互联网架构小马的博客
07-31 634
网络就像一把双刃剑，给我们的生活、交流、工作和发展带来了便利，但同时也给信息安全以及个人隐私带来了威胁。网络和信息安全问题不仅影响了网络的普及和应用，还关系到企国家、军队、企业的信息安全和社会的经济安全，让人又爱又恨。今天给大家分享的这份手册，主要从网络漏洞、协议和安全解决方案等方面来探讨网络安全问题。我们把网络看成是不安全和安全的源头，通过分析网络漏洞、探测、攻击和减少攻击的方法，来研究不同的网络协议。
【Vulnhub系列】Vulnhub Connect-The-Dots 靶场渗透（原创）
最新发布
Lusen的博客
08-02 568
Vulnhub系列Connect-The-Dots靶场做题记录
计算机网络—电路、分组、报文交换—图文详解
喻师傅的学习笔记
07-31 833
计算机网络—三种交换方式图文详解
Springboot+Websocket+Security+Vue 实现弹幕推送功能
Gemini1995的博客
08-01 635
【代码】Springboot+Websocket+Security+Vue 实现弹幕推送功能。
VFP程序设计基础：面向过程编程解析
- **对象与类**：虽然VF主要侧重于面向过程编程，但也支持面向对象编程。对象是具有属性和方法的数据实体，类是创建对象的模板。 - **继承与封装**：面向对象编程的核心特性，VF中的类可以继承其他类的属性和方法...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值