mingw 使用 HPSocket 进阶版

最新推荐文章于 2021-09-12 12:20:38 发布
最新推荐文章于 2021-09-12 12:20:38 发布
阅读量524 收藏
点赞数
分类专栏： 杂类 文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/a13576560181/article/details/120034646
版权 
#ifndef HPSOCKET4CWRAPPER_HPP
#define HPSOCKET4CWRAPPER_HPP

#include <cstdio>
#include <shared_mutex>
#include <optional>
#include <map>
#include <HPSocket4C.h>





/**
 * 如果 lambda 表达式不捕获任何外部变量，在特定的情况下，会有额外的代码生成。
 * 其中，特定情况是指：有 lambda_xxxx 类 到 函数指针 的类型转换
 */




template <typename T,typename V>
class VirtualTable{
    using mutex = std::shared_mutex;
    using lock_r = std::shared_lock<mutex>;
    using lock_w = std::unique_lock<mutex>;
public:
    bool add(const T& t,const V& v){
        lock_w lock(mtx);
        auto it = vt.find(t);
        if(it == vt.end()){
            vt.emplace(t,v);
            return true;
        }
        return false;
    }

    bool erase(const T& t){
        lock_w lock(mtx);
        auto it = vt.find(t);
        if(it != vt.end()){
            vt.erase(it);
            return true;
        }
        return false;
    }

    template<typename C,typename R,typename ...Arg>
    std::optional<R> doRead(R(C::*f)(T,Arg...),T t,Arg...arg){
        lock_r lock(mtx);
        auto it = vt.find(t);
        if(it != vt.end()){
            auto ptr = it->second;
            return std::make_optional((ptr->*f)(t,arg...));
        }
        return std::nullopt;
    }

private:
    std::map<T,V> vt;
    mutex mtx;
};



/**
 * 服务端基础类
 */
template  <typename Server,typename Listener>
class ServerBase{
public:
    void setServer(Server server){
        m_Server = server;
    }
    Server getServer() const{
        return m_Server;
    }
    void setListener(Listener listener){
        m_Listener = listener;
    }
    Listener getListener() const{
        return m_Listener;
    }

    BOOL start(const char * ip,unsigned int port) {
        return HP_Server_Start(m_Server, ip, port);
    }

    BOOL stop() {
        return HP_Server_Stop(m_Server);
    }

    BOOL sendPack(HP_CONNID dwConnID, const BYTE *pBuffer, int iLength) {
        return HP_Server_Send(m_Server, dwConnID, pBuffer, iLength);
    }

    BOOL sendPacks(HP_CONNID dwConnID, const WSABUF pBuffers[], int iCount) {
        return HP_Server_SendPackets(m_Server, dwConnID, pBuffers, iCount);
    }

    En_HP_ServiceState state(){
        return HP_Server_GetState(m_Server);
    }

private:
    Server m_Server;
    Listener m_Listener;
};



/**
 *  客户端基础类
 */
template <typename Client,typename Listener>
class ClientBase{
public:

    void setClient(Client client){
        m_Client = client;
    }
    Client getClient() const{
        return m_Client;
    }
    void setListener(Listener listener){
        m_Listener = listener;
    }
    Listener getListener() const{
        return m_Listener;
    }

    BOOL start(const char* m_IP,unsigned int PORT) {
        return HP_Client_Start(m_Client, m_IP, PORT, TRUE);
    }

    BOOL stop() {
        return HP_Client_Stop(m_Client);
    }

    BOOL sendPack(const BYTE *pBuffer, int iLength) {
        return HP_Client_Send(m_Client, pBuffer, iLength);
    }

    BOOL sendPacks(const WSABUF pBuffers[], int iCount) {
        return HP_Client_SendPackets(m_Client, pBuffers, iCount);
    }

    En_HP_ServiceState state(){
        return HP_Client_GetState(m_Client);
    }

private:
    Client m_Client;
    Listener m_Listener;
};







class TcpServer :public ServerBase<HP_TcpServer,HP_TcpServerListener>{
public:
    TcpServer(){
        setListener(Create_HP_TcpServerListener());
        HP_Set_FN_Server_OnPrepareListen(getListener(), [](HP_UdpServer pSender, SOCKET soListen){
            auto result = vt.doRead(&TcpServer::onPrepareListen,pSender,soListen);
            if(result.has_value()){
                return result.value();
            }
            return HR_IGNORE;
        });
        HP_Set_FN_Server_OnAccept(getListener(), [](HP_UdpServer pSender, HP_CONNID dwConnID, UINT_PTR pSockAddr){
            auto result = vt.doRead(&TcpServer::onAccept,pSender,dwConnID,pSockAddr);
            if(result.has_value()){
                return result.value();
            }
            return HR_IGNORE;
        });
        HP_Set_FN_Server_OnSend(getListener(), [](HP_UdpServer pSender, HP_CONNID dwConnID, const BYTE* pData, int iLength){
            auto result = vt.doRead(&TcpServer::onSend,pSender,dwConnID,pData,iLength);
            if(result.has_value()){
                return result.value();
            }
            return HR_IGNORE;
        });
        HP_Set_FN_Server_OnReceive(getListener(), [](HP_UdpServer pSender, HP_CONNID dwConnID, const BYTE* pData, int iLength){
            auto result = vt.doRead(&TcpServer::onReceive,pSender,dwConnID,pData,iLength);
            if(result.has_value()){
                return result.value();
            }
            return HR_IGNORE;
        });
        HP_Set_FN_Server_OnClose(getListener(), [](HP_UdpServer pSender, HP_CONNID dwConnID, En_HP_SocketOperation enOperation, int iErrorCode){
            auto result = vt.doRead(&TcpServer::onClose,pSender,dwConnID,enOperation,iErrorCode);
            if(result.has_value()){
                return result.value();
            }
            return HR_IGNORE;
        });
        HP_Set_FN_Server_OnShutdown(getListener(), [](HP_UdpServer pSender){
            auto result = vt.doRead(&TcpServer::onShutdown,pSender);
            if(result.has_value()){
                return result.value();
            }
            return HR_IGNORE;
        });
        setServer(Create_HP_TcpServer(getListener()));
        vt.add(getServer(),this);

    }

    virtual ~TcpServer(){
        vt.erase(getServer());
        Destroy_HP_TcpServer(getServer());
        Destroy_HP_TcpServerListener(getListener());
    }

protected:

    virtual En_HP_HandleResult onPrepareListen(HP_Server pSender, SOCKET soListen) = 0;
    virtual En_HP_HandleResult onAccept(HP_Server pSender, HP_CONNID dwConnID, SOCKET soClient)= 0;
    virtual En_HP_HandleResult onSend(HP_Server pSender, HP_CONNID dwConnID, const BYTE* pData, int iLength)= 0;
    virtual En_HP_HandleResult onReceive(HP_Server pSender, HP_CONNID dwConnID,const BYTE* pData, int iLength)= 0;
    virtual En_HP_HandleResult onClose(HP_Server pSender, HP_CONNID dwConnID, En_HP_SocketOperation enOperation, int iErrorCode)= 0;
    virtual En_HP_HandleResult onShutdown(HP_Server pSender) = 0;



private:

    inline static VirtualTable<HP_TcpServer,TcpServer*> vt;
};




class TcpClient :public ClientBase< HP_TcpClient,HP_TcpClientListener>{
public:
    TcpClient(){
        HP_Set_FN_Client_OnConnect(getListener(), [](HP_Client pSender, HP_CONNID dwConnID){
            auto result = vt.doRead(&TcpClient::onConnect,pSender,dwConnID);
            if(result.has_value()){
                return result.value();
            }
            return HR_IGNORE;
        });
        setListener(Create_HP_TcpClientListener());
        HP_Set_FN_Client_OnSend(getListener(), [](HP_Client pSender, HP_CONNID dwConnID, const BYTE* pData, int iLength){
            auto result = vt.doRead(&TcpClient::onSend,pSender,dwConnID,pData,iLength);
            if(result.has_value()){
                return result.value();
            }
            return HR_IGNORE;
        });
        HP_Set_FN_Client_OnReceive(getListener(), [](HP_Client pSender, HP_CONNID dwConnID, const BYTE* pData, int iLength){
            auto result = vt.doRead(&TcpClient::onReceive,pSender,dwConnID,pData,iLength);
            if(result.has_value()){
                return result.value();
            }
            return HR_IGNORE;

        });
        HP_Set_FN_Client_OnClose(getListener(), [](HP_Client pSender, HP_CONNID dwConnID, En_HP_SocketOperation enOperation, int iErrorCode){
            auto result = vt.doRead(&TcpClient::onClose,pSender,dwConnID,enOperation,iErrorCode);
            if(result.has_value()){
                return result.value();
            }
            return HR_IGNORE;
        });

        setClient(Create_HP_TcpClient(getListener()));
        vt.add(getClient(),this);

    }

    virtual ~TcpClient(){
        vt.erase(getClient());
        Destroy_HP_TcpClient(getClient());
        Destroy_HP_TcpClientListener(getListener());
    }

protected:

    virtual En_HP_HandleResult onConnect(HP_Client pSender, HP_CONNID dwConnID) = 0;
    virtual En_HP_HandleResult onSend(HP_Client pSender, HP_CONNID dwConnID, const BYTE* pData, int iLength)= 0;
    virtual En_HP_HandleResult onReceive(HP_Client pSender, HP_CONNID dwConnID, const BYTE* pData, int iLength)= 0;
    virtual En_HP_HandleResult onClose(HP_Client pSender, HP_CONNID dwConnID, En_HP_SocketOperation enOperation, int iErrorCode)= 0;


private:
    inline static VirtualTable<HP_TcpClient,TcpClient*> vt;
};



/**
 * pull 服务端的类
 */
template <typename INFO>
class TcpPullServer :public ServerBase<HP_TcpPullServer,HP_TcpPullServerListener>{
public:

    TcpPullServer(){
        setListener(Create_HP_TcpPullServerListener());
        HP_Set_FN_Server_OnPrepareListen(getListener(), [](HP_Server pSender, SOCKET soListen) {
            auto result = vt.doRead(&TcpPullServer::onPrepareListen,pSender,soListen);
            if(result.has_value()){
                return result.value();
            }
            return HR_IGNORE;
        });
        HP_Set_FN_Server_OnAccept(getListener(), [](HP_Server pSender, HP_CONNID dwConnID, SOCKET soClient) {
            auto result = vt.doRead(&TcpPullServer::onAccept,pSender,dwConnID,soClient);
            if(result.has_value()){
                return result.value();
            }
            return HR_IGNORE;
        });
        HP_Set_FN_Server_OnSend(getListener(), [](HP_Server pSender, HP_CONNID dwConnID, const BYTE *pData, int iLength) {
            auto result = vt.doRead(&TcpPullServer::onSend,pSender,dwConnID,pData,iLength);
            if(result.has_value()){
                return result.value();
            }
            return HR_IGNORE;

        });
        HP_Set_FN_Server_OnPullReceive(getListener(), [](HP_Server pSender, HP_CONNID dwConnID, int iLength) {
            auto result = vt.doRead(&TcpPullServer::onReceive,pSender,dwConnID,iLength);
            if(result.has_value()){
                return result.value();
            }
            return HR_IGNORE;
        });
        HP_Set_FN_Server_OnClose(getListener(), [](HP_Server pSender, HP_CONNID dwConnID, En_HP_SocketOperation enOperation, int iErrorCode) {
            auto result = vt.doRead(&TcpPullServer::onClose,pSender,dwConnID,enOperation,iErrorCode);
            if(result.has_value()){
                return result.value();
            }
            return HR_IGNORE;
        });
        HP_Set_FN_Server_OnShutdown(getListener(), [](HP_Server pSender) {
            auto result = vt.doRead(&TcpPullServer::onShutdown,pSender);
            if(result.has_value()){
                return result.value();
            }
            return HR_IGNORE;
        });
        setServer(Create_HP_TcpPullServer(getListener()));
        vt.add(getServer(),this);

    }

    virtual ~TcpPullServer() {
        Destroy_HP_TcpPullServerListener(getListener());
        Destroy_HP_TcpPullServer(getServer());
    }



    BOOL SetPkgInfo(HP_Server pSender, HP_CONNID dwConnID) {
        return HP_Server_SetConnectionExtra(pSender, dwConnID, new INFO);
    }

    INFO *FindPkgInfo(HP_Server pSender, HP_CONNID dwConnID) {
        PVOID pInfo = nullptr;
        HP_Server_GetConnectionExtra(pSender, dwConnID, &pInfo);
        return reinterpret_cast<INFO *>(pInfo);
    }

    void RemovePkgInfo(HP_Server pSender, HP_CONNID dwConnID) {
        INFO *pInfo = FindPkgInfo(pSender, dwConnID);
        if(pInfo != nullptr){
            delete pInfo;
        }
    }

protected:

    virtual En_HP_HandleResult onPrepareListen(HP_Server pSender, SOCKET soListen) = 0;
    virtual En_HP_HandleResult onAccept(HP_Server pSender, HP_CONNID dwConnID, SOCKET soClient) = 0;
    virtual En_HP_HandleResult onSend(HP_Server pSender, HP_CONNID dwConnID, const BYTE *pData, int iLength) = 0;
    virtual En_HP_HandleResult onReceive(HP_Server pSender, HP_CONNID dwConnID, int iLength) = 0;
    virtual En_HP_HandleResult onClose(HP_Server pSender, HP_CONNID dwConnID, En_HP_SocketOperation enOperation, int iErrorCode) = 0;
    virtual En_HP_HandleResult onShutdown(HP_Server pSender) = 0;


private:

    inline static VirtualTable<HP_TcpPullServer,TcpPullServer*> vt;

};







template <typename INFO>
class TcpPullClient :public ClientBase< HP_TcpPullClient,HP_TcpPullClientListener>{
public:



    explicit TcpPullClient() {
        setListener(Create_HP_TcpPullClientListener());

        HP_Set_FN_Client_OnConnect(getListener(), [](HP_Client pSender, HP_CONNID dwConnID) {
            auto result = vt.doRead(&TcpPullClient::onConnect,pSender,dwConnID);
            if(result.has_value()){
                return result.value();
            }
            return HR_IGNORE;
        });


        HP_Set_FN_Client_OnSend(getListener(), [](HP_Client pSender, HP_CONNID dwConnID, const BYTE *pData, int iLength) {
            auto result = vt.doRead(&TcpPullClient::onSend,pSender,dwConnID,pData,iLength);
            if(result.has_value()){
                return result.value();
            }
            return HR_IGNORE;
        });


        HP_Set_FN_Client_OnPullReceive(getListener(), [](HP_Client pSender, HP_CONNID dwConnID, int iLength) {
            auto result = vt.doRead(&TcpPullClient::onReceive,pSender,dwConnID,iLength);
            if(result.has_value()){
                return result.value();
            }
            return HR_IGNORE;
        });
        HP_Set_FN_Client_OnClose(getListener(), [](HP_Client pSender, HP_CONNID dwConnID, En_HP_SocketOperation enOperation, int iErrorCode) {
            auto result = vt.doRead(&TcpPullClient::onClose,pSender,dwConnID,enOperation,iErrorCode);
            if(result.has_value()){
                return result.value();
            }
            return HR_IGNORE;
        });
        setClient(Create_HP_TcpPullClient(getListener()));
        vt.add(getClient(),this);
    }

    virtual ~TcpPullClient() {
        vt.erase(getClient());
        Destroy_HP_TcpPullClient(getClient());
        Destroy_HP_TcpPullClientListener(getListener());

    }

    void SetPkgInfo(HP_Client pSender) {
        HP_Client_SetExtra(pSender, new INFO);
    }

    INFO *FindPkgInfo(HP_Client pSender) {
        PVOID pInfo = HP_Client_GetExtra(pSender);
        return reinterpret_cast<INFO *>(pInfo);
    }

    void RemovePkgInfo(HP_Client pSender) {
        INFO *pInfo = FindPkgInfo(pSender);
        if(pInfo != nullptr){
            delete pInfo;
        }
    }

protected:
    virtual En_HP_HandleResult onConnect(HP_Client pSender, HP_CONNID dwConnID) = 0;
    virtual En_HP_HandleResult onSend(HP_Client pSender, HP_CONNID dwConnID, const BYTE *pData, int iLength)  = 0;
    virtual En_HP_HandleResult onReceive(HP_Client pSender, HP_CONNID dwConnID, int iLength) = 0;
    virtual En_HP_HandleResult onClose(HP_Client pSender, HP_CONNID dwConnID, En_HP_SocketOperation enOperation, int iErrorCode) = 0;


private:

    inline static VirtualTable<HP_TcpPullClient,TcpPullClient*> vt;
};



class UdpServer :public ServerBase<HP_UdpServer,HP_UdpServerListener>{
public:

    explicit UdpServer(){

        setListener(Create_HP_UdpServerListener());
        HP_Set_FN_Server_OnPrepareListen(getListener(), [](HP_UdpServer pSender, SOCKET soListen){
            auto result = vt.doRead(&UdpServer::onPrepareListen,pSender,soListen);
            if(result.has_value()){
                return result.value();
            }
            return HR_IGNORE;
        });
        HP_Set_FN_Server_OnAccept(getListener(), [](HP_UdpServer pSender, HP_CONNID dwConnID, UINT_PTR pSockAddr){
            auto result = vt.doRead(&UdpServer::onAccept,pSender,dwConnID,pSockAddr);
            if(result.has_value()){
                return result.value();
            }
            return HR_IGNORE;
        });
        HP_Set_FN_Server_OnSend(getListener(), [](HP_UdpServer pSender, HP_CONNID dwConnID, const BYTE* pData, int iLength){
            auto result = vt.doRead(&UdpServer::onSend,pSender,dwConnID,pData,iLength);
            if(result.has_value()){
                return result.value();
            }
            return HR_IGNORE;
        });
        HP_Set_FN_Server_OnReceive(getListener(), [](HP_UdpServer pSender, HP_CONNID dwConnID, const BYTE* pData, int iLength){
            auto result = vt.doRead(&UdpServer::onReceive,pSender,dwConnID,pData,iLength);
            if(result.has_value()){
                return result.value();
            }
            return HR_IGNORE;
        });
        HP_Set_FN_Server_OnClose(getListener(), [](HP_UdpServer pSender, HP_CONNID dwConnID, En_HP_SocketOperation enOperation, int iErrorCode){
            auto result = vt.doRead(&UdpServer::onClose,pSender,dwConnID,enOperation,iErrorCode);
            if(result.has_value()){
                return result.value();
            }
            return HR_IGNORE;
        });
        HP_Set_FN_Server_OnShutdown(getListener(), [](HP_UdpServer pSender){
            auto result = vt.doRead(&UdpServer::onShutdown,pSender);
            if(result.has_value()){
                return result.value();
            }
            return HR_IGNORE;
        });
        setServer(Create_HP_UdpServer(getListener()));
        vt.add(getServer(),this);
    }

    virtual ~UdpServer(){
        vt.erase(getServer());
        Destroy_HP_UdpServer(getServer());
        Destroy_HP_UdpServerListener(getListener());
    }

protected:

    virtual En_HP_HandleResult onPrepareListen(HP_UdpServer pSender, SOCKET soListen) = 0;
    virtual En_HP_HandleResult onAccept(HP_UdpServer pSender, HP_CONNID dwConnID, UINT_PTR pSockAddr)= 0;
    virtual En_HP_HandleResult onSend(HP_UdpServer pSender, HP_CONNID dwConnID, const BYTE* pData, int iLength)= 0;
    virtual En_HP_HandleResult onReceive(HP_UdpServer pSender, HP_CONNID dwConnID, const BYTE* pData, int iLength)= 0;
    virtual En_HP_HandleResult onClose(HP_UdpServer pSender, HP_CONNID dwConnID, En_HP_SocketOperation enOperation, int iErrorCode)= 0;
    virtual En_HP_HandleResult onShutdown(HP_UdpServer pSender)= 0;


private:

    inline static VirtualTable<HP_UdpServer,UdpServer*> vt;




};





using CTcpServer = TcpServer;
using CTcpClient = TcpClient;

template <typename INFO>
using CTcpPullServer = TcpPullServer<INFO>;

template <typename INFO>
using CTcpPullClient = TcpPullClient<INFO>;


using CUdpServer = UdpServer;




#endif // HPSOCKET4CWRAPPER_HPP

FRAM
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
通用高性能 Windows Socket 组件 HP-Socket
08-20
HP-Socket 是一套通用的高性能 Windows Socket 组件包，包含服务端组件（IOCP 模型）和客户端组件（Event Select 模型），广泛适用于 Windows 平台的 TCP 通信系统。
Mingw使用HPSocket的包装类
FRAM的博客
05-27 606
首先，HPSocket是一个很好的开源网络项目，支持跨平台，Windows,Linux，Android,MacOS等等。但是就Windows平台而言，它的开发环境是VisualStudio。由于c++编译器的差异，Mingw和Mingw64是无法调用HPSocket的c++动态链接库的，因此我们只能使用HPSocket的c语言动态库。但是对于习惯使用c++的人来说，使用c语言是一件感觉很不好的是，就像现代人，突然回到了原始社会一样，在c语言中，没有c++的各种武器，并且函数、变量分散，阅读代码...
高性能跨平台网络通信框架 HP-Socket v5.4.2
Ldcsaa的博客
11-01 625
项目主页 : http://www.oschina.net/p/hp-socket 开发文档 : http://www.docin.com/p-2137713732.html 下载地址 : https://github.com/ldcsaa/HP-Socket QQ Group: 75375912, 44636872 HP-Socket提供以下几类组件，详细内容请参考《HP-Socket网络...
HPSocket4C 静态库（32和64位版本）
09-29
文件是HPSocket4C版本的，包含头文件就可以使用了，已经编译好！
HP-Socket v5.4.4 发布，高性能跨平台网络通信框架
weixin_33701564的博客
03-04 200
百度智能云 云生态狂欢季 热门云产品1折起>>> HP-Socket提供以下几类组件，详细内容请参考...
MinGW编译的opencv4.7版本
最新发布
06-03
这个压缩包“MinGW编译的opencv4.7版本”意味着它包含了使用MinGW编译器构建的OpenCV库，适用于在Windows系统上进行开发。 OpenCV 4.7版是该库的一个较新版本，提供了许多改进和新功能。在这一版本中，开发者可以...
MinGW安装集使用.docx
08-09
MinGW 安装集使用教程 MinGW 是一个精简的 Windows 平台 C/C++、ADA 及 Fortran 编译器，相比 Cygwin 而言，体积要小很多，使用较为方便。MinGW 最大的特点就是编译出来的可执行文件能够独立在 Windows 上运行。...
mingw免安装版，直接解压就能使用
05-26
MingW免安装版是其的一种便捷形式，用户无需经历传统的安装过程，只需将压缩包解压到指定位置，即可开始使用。 对于源码软件，MingW扮演了至关重要的角色。它提供了C、C++、Objective-C、Fortran等多种编程语言的...
Mingw-w64 免安装版
04-20
这个版本的Mingw-w64特别方便，因为它不需要通过复杂的安装过程，只需解压即可开始使用，正如描述中所说的，“解压即用，亲测可行”。 首先，让我们深入了解一下Mingw-w64。Mingw-w64是MinGW（Minimalist GNU for ...
GCC编译器mingw版本v10.0.0
06-19
而且还可以使用一些 Windows 不具备的，Linux平台下的开发工具。一句话来概括：MinGW 就是 GCC 的 Windows 版本 。 MinGW-w64 与 MinGW 的区别在于 MinGW 只能编译生成32位可执行程序，而 MinGW-w64 则可以编译生成 ...
HP-Socket下载
04-23
HP-Socket 是一套通用的高性能 TCP/UDP 通信框架，包含服务端组件、客户端组件和 Agent 组件，广泛适用于各种不同应用场景的 TCP/UDP 通信系统，提供 C/C++、C#、Delphi、E（易语言）、Java、Python 等编程语言接口。HP-Socket 对通信层实现完全封装，应用程序不必关注通信层的任何细节；HP-Socket 提供基于事件通知模型的 API 接口，能非常简单高效地整合到新旧应用程序中。 　　为了让使用者能方便快速地学习和使用 HP-Socket，迅速掌握框架的设计思想和使用方法，特此精心制作了大量 Demo 示例（如：PUSH 模型示例、PULL 模型示例、性能测试示例以及其它编程语言示例）。HP-Socket 目前运行在 Windows 平台，将来会实现跨平台支持。
HP-Socket
u012129372的专栏
04-04 4489
HP-Socket 是一套通用的高性能 Windows Socket 组件包，包含服务端组件（IOCP 模型）和客户端组件（Event Select 模型），广泛适用于 Windows 平台的 TCP 通信系统。HP-Socket 对通信层实现完全封装，上层应用不必关注通信层的任何细节；HP-Socket 提供基于事件通知模型的 API 接口，能非常简单高效地整合到各类应用程序中；另外，为了让大家
高性能 TCP/UDP/HTTP 通信框架 HP-Socket v4.0.1
weixin_34125592的博客
10-12 111
　　HP-Socket 是一套通用的高性能 TCP/UDP/HTTP 通信框架，包含服务端组件、客户端组件和 Agent 组件，广泛适用于各种不同应用场景的 TCP/UDP/HTTP 通信系统，提供 C/C++、C#、Delphi、E（易语言）、Java、Python 等编程语言接口。HP-Socket 对通信层实现完全封装，应用程序不必关注通信层的任何细节；HP-Socket 提供基于事件通...
高性能 TCP/UDP/HTTP 通信框架 HP-Socket v4.1.1
~怪*_^兽~ 技术专栏
11-30 1938
HP-Socket 是一套通用的高性能 TCP/UDP/HTTP 通信框架，包含服务端组件、客户端组件和 Agent 组件，广泛适用于各种不同应用场景的 TCP/UDP/HTTP 通信系统，提供 C/C++、C#、Delphi、E（易语言）、Java、Python 等编程语言接口。HP-Socket 对通信层实现完全封装，应用程序不必关注通信层的任何细节；HP-Socket 提供基于事件通知模型的 API 接口，能非常简单高效地整合到新旧应用程序中。
高性能通信框架 HP-Socket v4.1.1
weixin_34292402的博客
12-01 367
　　HP-Socket 是一套通用的高性能 TCP/UDP/HTTP 通信框架，包含服务端组件、客户端组件和 Agent 组件，广泛适用于各种不同应用场景的 TCP/UDP/HTTP 通信系统，提供 C/C++、C#、Delphi、E（易语言）、Java、Python 等编程语言接口。HP-Socket 对通信层实现完全封装，应用程序不必关注通信层的任何细节；HP-Socke...
高性能 Socket 组件 HP-Socket v3.2.1-RC3 公布
weixin_30606461的博客
03-19 233
　　HP-Socket 是一套通用的高性能 TCP/UDP Socket 组件，包括服务端组件、client组件和 Agent 组件，广泛适用于各种不同应用场景的 TCP/UDP 通信系统。提供 C/C++、C#、Delphi、E、Java 等编程语言开发接口。HP-Socket 对通信层实现全然...
HP-SOCKET 使用C方法-Pull
u011269801的专栏
09-12 1165
包含Windows\Include\HPSocket头文件 HPSocket4C_U.lib、HPSocket4C_UD.lib 库文件 1、服务器： （1）Server.h #pragma once #include "HPSocket4C.h" const LPCTSTR DEF_ADDRESS = _T("0.0.0.0"); const USHORT PORT = 9700; class Server { public: Server(); ~Serv...
高性能 Socket 组件 HP-Socket v3.1.3 正式发布
~怪*_^兽~ 技术专栏
03-31 1373
HP-Socket 是一套通用的高性能 Windows Socket 组件，提供服务端组件（IOCP 模型）和客户端组件（Event Select 模型），广泛适用于 Windows 平台的 TCP/UDP 通信系统。HP-Socket 对通信层实现完全封装，上层应用不必关注通信层的任何细节；HP-Socket 提供基于事件通知模型的 API 接口，能非常简单高效地整合到各类应用程序中；另外，为了
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值