Boost库之bind适配器学习

最新推荐文章于 2021-11-05 23:40:42 发布
最新推荐文章于 2021-11-05 23:40:42 发布
阅读量1.2k 收藏 1
点赞数 1
CC 4.0 BY-SA版权
分类专栏： Boost 文章标签： boost function 多线程 服务器
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/zmyer/article/details/19552849

最近在学习boost库里的一些常用的库，目前已经看到了boost库的bind适配器这块，个人感觉bind这玩意太好用了，整体来讲bind要比STL里的bind1st和bind2nd要好用很多，下面就从一些基本的用法来说起吧，bind组件在boost中包含了很多的重载函数，其中这些函数主要是以参数的个数以及被绑定的对象类型来划分，而编译器会根据具体的参数类型以及参数个数来自动地调用相关的形式，在bind中，接收的一个参数必定是一个可调用的对象，这个对象可以是普通函数，函数指针以及类的成员函数，而之后，bind最多可以接收9个参数，这些参数的个数必定和传入的可调用的对象的参数数量相等。在绑定完成之后，bind会返回一个函数对象，并且在内部保留了可调用对象的拷贝，具有operator（），返回类型会被自动推导为可调用对象的返回类型，其他的就不说了，具体来看代码吧，代码如下：

1.普通函数和函数指针

#include <boost/bind.hpp>
#include <boost/function.hpp>
#include <iostream>
#include <stdio.h>
using namespace boost;
using namespace std;

void worker()
{
    printf("this is empty argument\n");
}

void worker(int a,int b)
{
    int sum = a + b;
    printf("this is two argument,sum=%d\n",sum);
}

template<class T>
void worker1(T a,T b)
{
    printf("this is a tempate function,a=%f,b=%f\n",a,b);
}

typedef void (*pFunc1)();
typedef void (*pFunc2)(int,int);
int main()
{
    int x = 2,y=3;
    double z = 2.1,w = 2.4;

    boost::bind(worker,x,y)();
    boost::bind(worker,x,x)();
    boost::bind(worker,y,y)();

    boost::bind(worker,_1,_2)(x,y);
    boost::bind(worker,_1,_1)(x,y);
    boost::bind(worker,_2,_2)(x,y);

    pFunc1 func1;
    pFunc2 func2;
    func1 = worker;
    func2 = worker;
    boost::bind(func1)();
    boost::bind(func2,x,y)();
    boost::bind(func2,_1,_2)(x,y);

    //boost::bind<double>(worker1<double>,z,w)();
    //boost::bind<double>(worker1<double>,_1,_2)(z,w);
    //boost::bind<double>(worker1<double>,_2,_1)(z,w);
    return 0;
}

2.成员函数和函数对象

struct demo
{
    demo()
    {
        x = y = 0;
    }
    demo(int x,int y):x(x),y(y)
    {
    }
    void display()
    {
        cout<<"x="<<x<<" "<<"y="<<y<<endl;
    }
    void operator()(int a,int b)
    {
        x = a;
        y = b;
        display();
    }
    int x,y;
};
int main()
{
    demo demo1(1,2);
    demo& demo2 = demo1;
    demo* demo3 = &demo2;

    boost::bind(&demo::display,demo1)();
    boost::bind(&demo::display,demo2)();
    boost::bind(&demo::display,demo3)();

    vector<demo> demolist(10);
    for_each(demolist.begin(),demolist.end(),bind(&demo::display,_1));

    boost::bind<void>(demo(),_1,_2)(100,200);
    boost::bind<void>(demo(),200,400)();
    return 0;
}

好了，bind的一些基本的操作差不多介绍完了，下面我们想借助boost：：bind来完成一个稍微复杂点的小功能，这个功能也是参考了陈硕同学的blog有感而发，下面就用bind和function来实现一个简单点的服务器框架吧，代码如下：

1.网络库方面

#ifndef __CONNECTION__H
#define __CONNECTION__H

#include <iostream>
#include <stdio.h>
#include <sys/socket.h>
#include <sys/epoll.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <fcntl.h>
#include <unistd.h>
#include <errno.h>
using namespace std;

class Connection
{
    public:
        Connection(string ip = string(),int port = 0):peerIp(ip),peerPort(port)
        {
            sock = -1;
        }
        ~Connection(){}

        Connection(const Connection& conn)
        {
            sock = conn.sock;
            peerIp = conn.peerIp;
            peerPort = conn.peerPort;
        }

        Connection& operator = (const Connection& conn)
        {
            if(this == &conn) return *this;
            sock = conn.sock;
            peerIp = conn.peerIp;
            peerPort = conn.peerPort;
        }

        int recv(void* buffer,int size)
        {
            return ::recv(sock,buffer,size,0);
        }
        int send(const void* buffer,int size)
        {
            return ::send(sock,buffer,size,0);
        }
        void displayConnInfo()
        {
            printf("peerIp:%s,peerPort:%d\n",peerIp.c_str(),peerPort);
        }

        void setSock(int sockfd)
        {
            sock = sockfd;
        }
        void setPeerIp(char* ip)
        {
            peerIp = ip;
        }
        void setPeerPort(int port)
        {
            peerPort = port;
        }
        int getSock()const
        {
            return sock;
        }
        string getPeerIp()const
        {
            return peerIp;
        }
        int getPeerPort() const
        {
            return peerPort;
        }
     private:
        int sock;
        string peerIp;
        int peerPort;
};
#endif

#ifndef __NETSERVER__H
#define __NETSERVER__H
#include <boost/function.hpp>
#include <boost/bind.hpp>
#include <vector>
#include "Connection.h"
using namespace std;
#define MAX_EVENTS 255
class NetServer
{
    public:
        typedef boost::function<void(Connection*)> ConnectionCallback;
        typedef boost::function<void(Connection*,const void*,int)> SendMessageCallback;
        typedef boost::function<void(Connection*,void*,int&)> RecvMessageCallback;

        NetServer(int port):port(port)
        {
            sock = -1;
            epollfd = epoll_create(MAX_EVENTS);
            connVec.clear();
        }
        ~NetServer(){}

        bool initNetServer()
        {
            sock = ::socket(AF_INET,SOCK_STREAM,0);
            if(-1 == sock)
            {
                perror("sock init failed\n");
                return false;
            }
            setNonBlock(sock);
            struct sockaddr_in serverAddr;
            bzero(&serverAddr,sizeof(serverAddr));
            serverAddr.sin_family = AF_INET;
            serverAddr.sin_port = htons(port);
            serverAddr.sin_addr.s_addr = htons(INADDR_ANY);

            if(bind(sock,(struct sockaddr*)&serverAddr,sizeof(serverAddr))<0)
            {
                perror("bind sock failed\n");
                return false;
            }
            if(listen(sock,10)<0)
            {
                perror("listen sock failed\n");
                return false;
            }
            addEvent(epollfd,EPOLLIN,sock);
            return true;
        }

        void setNonBlock(int sockfd)
        {
            int ops;
            ops = fcntl(sock,F_GETFL);
            if(ops<0)
            {
                perror("fcntl get sock failed\n");
                exit(1);
            }

            ops = ops | O_NONBLOCK;
            if(fcntl(sock,F_SETFL,ops)<0)
            {
                perror("fcntl set sock failed\n");
                exit(1);
            }
        }

        bool addEvent(int epollfd,int events,int sock)
        {
            struct epoll_event ev;
            bzero(&ev,sizeof(ev));
            ev.data.fd = sock;
            ev.events = events;
            if(epoll_ctl(epollfd,EPOLL_CTL_ADD,sock,&ev)<0)
            {
                perror("add epoll failed\n");
                return false;
            }
            return true;
        }

        bool delEvent(int epollfd,int events,int sock)
        {
            struct epoll_event ev;
            bzero(&ev,sizeof(ev));
            ev.data.fd = sock;
            ev.events = events;
            if(epoll_ctl(epollfd,EPOLL_CTL_DEL,sock,&ev)<0)
            {
                perror("del epoll failed\n");
                return false;
            }
            return true;
        }
        Connection getNetServerConnection(int sockfd)
        {
            Connection temp;
            for(connVecIter iter = connVec.begin();iter != connVec.end();++iter)
            {
                if(iter->getSock() == sockfd)
                    return *iter;
            }
            return temp;
        }

        void boardcast(Connection* conn)
        {
            char buffer[1024];
            int recvlen = 0;
            bzero(buffer,sizeof(buffer));

            //recvMsgCallback(conn,buffer,recvlen);
            recvlen = conn->recv(buffer,sizeof(buffer));
            printf("MSG:%s\n",buffer);
            for(int i=0;i<connVec.size();i++)
            {
                if(connVec[i].getSock() == conn->getSock()) continue;
                sendMsgCallback(&connVec[i],buffer,recvlen);
            }

        }
        void loop()
        {
            int nfds,connfd;
            socklen_t clientlen;

            struct sockaddr_in clientaddr;
            struct epoll_event events[MAX_EVENTS];
            bzero(events,sizeof(events));
            for(;;)
            {
                nfds = epoll_wait(epollfd,events,MAX_EVENTS,500);
                for(int i=0;i<nfds;i++)
                {
                    if(events[i].data.fd == sock)
                    {
                        Connection conn;
                        bzero(&clientaddr,sizeof(clientaddr));
                        connfd = ::accept(sock,(struct sockaddr*)&clientaddr,&clientlen);
                        if(connfd < 0)
                        {
                            perror("accept failed\n");
                            continue;
                        }
                        setNonBlock(connfd);
                        addEvent(epollfd,EPOLLIN | EPOLLET,connfd);
                        conn.setSock(connfd);
                        conn.setPeerIp(inet_ntoa(clientaddr.sin_addr));
                        conn.setPeerPort(ntohs(clientaddr.sin_port));
                        connCallback(&conn);
                        connVec.push_back(conn);
                        printf("connVec.size():%d\n",connVec.size());
                    }
                    else if(events[i].events & EPOLLIN)
                    {
                        if(events[i].data.fd < 0) continue;
                        Connection conn = getNetServerConnection(events[i].data.fd);
                        if(conn.getSock()!=-1)
                            boardcast(&conn);
                    }
                }
            }
        }
        void registerConnectionCallback(const ConnectionCallback& f)
        {
            connCallback = f;
        }
        void registerSendMsgCallback(const SendMessageCallback& f)
        {
            sendMsgCallback = f;
        }
        void registerRecvMsgCallback(const RecvMessageCallback& f)
        {
            recvMsgCallback = f;
        }
        void sendMsg(Connection* conn,const void* buff,int len)
        {
            assert(conn);
            conn->send(buff,len);
        }
        int recvMsg(Connection* conn,void* buff,int& len)
        {
            assert(conn);
            return conn->recv(buff,len);
        }
    private:
        int sock;
        int port;
        int epollfd;
        ConnectionCallback connCallback;
        SendMessageCallback sendMsgCallback;
        RecvMessageCallback recvMsgCallback;
        std::vector<Connection> connVec;
        typedef std::vector<Connection>::iterator connVecIter;
};
#endif

2.实际使用的服务器代码

#ifndef __ECHO_SERVER__H
#define __ECHO_SERVER__H
#include<boost/function.hpp>
#include<boost/bind.hpp>
#include<iostream>
#include<stdio.h>
#include "Connection.h"

class EchoServer
{
    public:
        typedef boost::function<void(Connection*,const void*,int)> SendMessageCallback;
        typedef boost::function<void(Connection*,void*,int&)> RecvMessageCallback;
        EchoServer(const SendMessageCallback& sendMsgCb,const RecvMessageCallback& recvMsgCb):sendMessageCb_(sendM
        {
        }
        void onSendMessage(Connection* conn,const void* buff,int size)
        {
            conn->displayConnInfo();
            sendMessageCb_(conn,buff,size);
        }
        void onRecvMessage(Connection* conn,void* buff,int& size)
        {
            conn->displayConnInfo();
            recvMessageCb_(conn,buff,size);
        }
        void onConnection(Connection* conn)
        {
            conn->displayConnInfo();
        }
    private:
        SendMessageCallback sendMessageCb_;
        RecvMessageCallback recvMessageCb_;
};
#endif

服务器端测试程序：

#include "NetServer.h"
#include "EchoServer.h"

int main()
{
    NetServer netServer(19999);
    EchoServer echoServer(bind(&NetServer::sendMsg,&netServer,_1,_2,_3),bind(&NetServer::recvMsg,&netServer,_1,_2,
    netServer.registerSendMsgCallback(bind(&EchoServer::onSendMessage,&echoServer,_1,_2,_3));
    netServer.registerRecvMsgCallback(bind(&EchoServer::onRecvMessage,&echoServer,_1,_2,_3));
    netServer.registerConnectionCallback(bind(&EchoServer::onConnection,&echoServer,_1));
    netServer.initNetServer();
    netServer.loop();
    return 0;
}

客户端测试程序：

#ifndef __LIBEVENT_SERVER__H
#define __LIBEVENT_SERVER__H
#include <iostream>
#include <string>
#include <string.h>
#include <stdlib.h>
#include <vector>
#include <event.h>
#include <boost/smart_ptr.hpp>
#include <pthread.h>
#include <sys/socket.h>
#include <sys/epoll.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdio.h>
#include <errno.h>
#include <fstream>
#include <iterator>
using namespace std;
using namespace boost;

#define MAX_CONN 10
#define MAX_BUFFERSIZE 1024

#define EVENT_INIT {event_init();}
namespace zmyer
{
    struct Info
    {
        Info()
        {
            fd= -1;
            clientname.clear();
        }
        Info(const Info& in)
        {
            clientname = in.clientname;
            fd = in.fd;
        }
        Info(const Info* in)
        {
            clientname = in->clientname;
            fd = in->fd;
        }
        ~Info(){}

        string clientname;
        int fd;
    };

    struct Msg
    {
        Msg()
        {
            clientname.clear();
            msg.clear();
        }
        Msg(const Msg& ms)
        {
            clientname = ms.clientname;
            msg = ms.msg;
        }
        Msg& operator = (const Msg& ms)
        {
            clientname = ms.clientname;
            msg = ms.msg;
        }
        ~Msg(){}

        void setClientName(string clientname)
        {
            this->clientname = clientname;
        }
        void setMsg(string msg)
        {
            this->msg = msg;
        }
        string serialize()
        {
            string tag = "#";
            return (clientname + tag + msg);
        }
        void unserialize(string message)
        {
            string tag = "#";
            string::size_type pos = message.find(tag);
            if(pos == string::npos)
            {
                clientname ="";
                msg = "";
            }
            else
            {
                clientname.assign(message,0,pos);
                msg.assign(message,pos+1,(message.length() - pos));
            }
        }

        string clientname;
        string msg;
    };

    static void* send(void* arg)
    {
        shared_ptr<Info> p(new Info((Info*)arg));
        string line,buffer;
        for(;;)
        {
            line.clear();
            buffer.clear();
            getline(cin,line);
            Msg msg;
            msg.clientname = p->clientname;
            msg.msg = line;
            buffer = msg.serialize();
            ::send(p->fd,buffer.c_str(),strlen(buffer.c_str()),0);
        }
        return NULL;
    }
    static void* recv(void* arg)
    {
        shared_ptr<Info> p(new Info((Info*)arg));
        char buffer[MAX_BUFFERSIZE];
        for(;;)
        {
            bzero(buffer,sizeof(buffer));
            int readlen = ::recv(p->fd,buffer,sizeof(buffer),0);
            if(readlen <=0)
                continue;
            Msg msg;
            msg.unserialize(buffer);
            if(msg.clientname !="")
            {
                printf("%s : %s\n",msg.clientname.c_str(),msg.msg.c_str());
            }
        }
        return NULL;
    }

    class libeventClient
    {
        public:
            libeventClient(string ip = string(),string clientname = string(),const int port = 0):ip(ip),clientname
        {
            sock = -1;
        }
            ~libeventClient(){}

            bool init()
            {
                sock = ::socket(AF_INET,SOCK_STREAM,0);
                if(-1 == sock)
                {
                    printf("sock init failed\n");
                    return false;
                }
                struct sockaddr_in client_addr;
                bzero(&client_addr,sizeof(client_addr));
                client_addr.sin_family = AF_INET;
                client_addr.sin_port = htons(0);
                client_addr.sin_addr.s_addr = htons(INADDR_ANY);
                if(bind(sock,(struct sockaddr*)&client_addr,sizeof(client_addr))<0)
                {
                    printf("bind the address failed\n");
                    return false;
                }
                struct sockaddr_in server_addr;
                bzero(&server_addr,sizeof(server_addr));
                server_addr.sin_family = AF_INET;
                server_addr.sin_port = htons(port);
                inet_aton(ip.c_str(),&(server_addr.sin_addr));
                if(::connect(sock,(struct sockaddr*)&server_addr,sizeof(server_addr))<0)
                {
                    printf("connect to libeventserver failed\n");
                    return false;
                }
                return true;
            }

            void startSendThread()
            {
                Info in;
                in.fd = sock;
                in.clientname = clientname;
                pthread_create(&sendThread,NULL,&send,&in);
            }
            void startRecvThread()
            {
                Info in;
                in.fd = sock;
                in.clientname = clientname;
                pthread_create(&recvThread,NULL,&recv,&in);
            }
            void run()
            {
                startSendThread();
                startRecvThread();
            }
            void stop()
            {
                pthread_join(sendThread,NULL);
                pthread_join(recvThread,NULL);
            }
        private:
            string ip;
            string clientname;
            int port;
            int sock;
            pthread_t recvThread,sendThread;
    };
}
#endif

#include "libeventServer.h"
using namespace zmyer;

int main(int argc,char** argv)
{
    if(argc < 2)
    {
        printf("usage:%s <clientname>\n",argv[0]);
        return 0;
    }
    libeventClient libClient("127.0.0.1",argv[1],19999);
    if(!libClient.init())
    {
        printf("libClient init failed\n");
        return 0;
    }
    libClient.run();
    sleep(60);
    libClient.stop();
    return 0;
}

测试结果：

服务器:

peerIp:0.0.0.0,peerPort:0
connVec.size():1
peerIp:127.0.0.1,peerPort:34423
connVec.size():2
MSG:B#hello,everyone
peerIp:0.0.0.0,peerPort:0
MSG:B#today is a good day!!!!!
peerIp:0.0.0.0,peerPort:0
MSG:A#en,what is your plan today????
peerIp:127.0.0.1,peerPort:34423

客户端A：

B : hello,everyone
B : today is a good day!!!!!
en,what is your plan today????
客户端B:

hello,everyone
today is a good day!!!!!
A : en,what is your plan today????

总结

        这篇博文主要是学习了下boost：：bind的一些常见用法，并且配合bind：：function写了一个简单的服务器框架，在此基础上又重新改写了聊天室程序，通过使用echoServer这个类来扩展框架中的一些比较核心功能，在NetServer中主要是负责底层的事件监听，消息的发送，而上层EchoServer类主要是针对这些事件进行一些上层的预处理，本案例只是一个简单的测试用例，没有过多地扩展Connection和NetServer的功能，等有时间的话，在扩展一些功能，好了，本篇博文到此结束，其中有些东西也是参考了别人的案例加上自己的瞎想写的，不乏有错误，请见谅

如果需要，请注明转载，多谢
 

boost::container模块实现范围分配器适配器
希望我的博客，能帮上你解决学习中工作中所遇到的问题
05-26 313
boost::container模块实现范围分配器适配器实现功能C++实现代码 实现功能 boost::container模块实现范围分配器适配器 C++实现代码 #include <boost/container/scoped_allocator_fwd.hpp> #include <boost/container/detail/mpl.hpp> // move #include <boost/move/utility_core.hpp> #include <bo
【BOOST C++库】BOOST C++库20个分类指南
gongdiwudu的专栏
11-21 5622
我们强调与 C++ 标准库配合良好的库。 Boost 库旨在广泛使用，并可用于广泛的应用程序。 Boost 许可证鼓励所有用户以最少的限制使用 Boost 库。
C++ Boost库：绑定库 bind
超级大洋葱的博客
05-05 1252
文章目录1. STL中bind1st,bind2nd的使用2. 示例代码 1. STL中bind1st,bind2nd的使用 先回忆下标准库函数对象及适配器bind1st、bind2nd，都可以把一个二元函数对象绑定成为一个元函数对象，区别是bind1st是绑定第一个参数bind2nd则是绑定第二个参数。 2. 示例代码 #include<boost/bind.hpp> using namespace boost; //名字空间 #include<iostream> using
boost::bind
weixin_40603219的博客
03-16 619
https://www.cnblogs.com/blueoverflow/p/4740093.html //注册action服务 //注册action的回调函数execute //把_1和server作为两个参数，每次调用回调函数都把这两个参数传进去 //_1是占用符，详见https://www.cnblogs.com/blueoverflow/p/4740093.html actionlib...
【Boost】boost库中function和bind一起使用的技巧（二）
liujiayu2的专栏
01-28 1801
与 Boost.Function 一起使用 Boost.Bind   当我们把 Boost.Function 与某个支持参数绑定的库结合起来使用时，事情变得更为有趣。Boost.Bind 为普通函数、成员函数以及成员变量提供参数绑定。这非常适合于 Boost.Function, 我们常常需要这类绑定，由于我们使用的类本身并不是函数对象。那么，我们用 Boost.Bind 把它们转变为函数
封装bst thd
byytj
09-25 302
封装 4人收藏此文章, 我要收藏 发表于3个月前(2012-06-11 23:08) , 已有313次阅读 共6个评论 最近在看陈硕的MUDUO网络通信库的过程中，发现作者大量使用了Boost::function以及Boost::bind功能，为了能够正常的学习作者的代码，决定先弄明白function以及bind的功能。       Boost::Function 是对函数指针的对...
掌握Boost库：bind与function消息处理框架入门指南
Boost库中的Bind和Function组件是其功能强大的一部分，它们为C++编程语言提供了更加灵活和强大的函数对象操作能力。 首先，要理解基于Boost的bind与function的消息处理框架，我们需要了解几个核心概念：函数对象...
C++“准”标准库Boost学习指南(9)：Boost.Bind
cbNotes的专栏：不积硅步，无以至千里;不积小流，无以成江海!
10-19 1892
Boost.Bind Bind是对标准库的绑定器bind1st 和 bind2nd的泛化。这个库支持使用统一的语法将参数绑定到任何类似于函数行为的东西，如函数指针、函数对象，以及成员函数指针。它还可以通过嵌套绑定器实现函数组合。这个库不要求那些对标准库绑定器的强制约束，最显著的就是不要求你的类提供typedefs result_type, first_argument_type, 和 sec
Boost库学习资料.rar
07-19
例如，Boost.Iterator库提供了各种迭代器适配器，使开发者能够创建自定义迭代器；Boost.Range库则提供了一种统一处理各种序列的方式，无论它们是数组、容器还是其他数据结构。此外，Boost.Bind和Boost.Lambda可以...
Boost bind使用方法
MachiealFactory的博客
07-01 716
bind是C++98 标准库中函数适配器，bind1st和bind2nd的泛化和增强，可以适配任意的可调用对象，包括函数指针吗， 函数引用，成员函数，指针和函数对象。bind远远超过了STL中的函数绑定，最多可以绑定9个参数，并且对绑定对象要求很低，bind很好的增强了 标准库的功能，已经被收入C++0XTR1草案。 bind 位于boost命名空间 头文件: boost/bind.h
linux socket 设置从哪个网络设备发送数据 SO_BINDTODEVICE
openCpu
10-27 4685
m_SockFd = socket(AF_INET, SOCK_STREAM, 0); if (m_SockFd==-1) { LOG4CPLUS_ERROR(logger, "opening stream socket ," <<__FILE__ <<" , "<<__LINE__ ); return 1; } // 绑定网络路由，eth0 or wlan0
boost socket 用法
ghosthjt的专栏
03-30 8116
<br />boost socket 用法<br />要用得明白,必须还要了解endpoint,它用来设置ip,端口,协议类型.<br /><br />1.asio::ip::tcp::acceptor  侦听类socket用法<br />用法示例:<br /> <br />boost::asio::io_service io_service_;<br />boost::asio::ip::tcp::acceptor acc(io_service_);<br />//这步创建了一个有效的socket.<br
Boost学习系列4-事件处理(下)
JuanA1的专栏
07-28 3530
合成器是一个重载了 operator()() 操作符的类。这个操作符会被自动调用，传入两个迭代器，指向某个特定信号的所有返回值。以上例子使用了标准 C++ 算法 std::min_element() 来确定并返回最小的值。    不幸的是，我们不可能把象 std::min_ele
关于boost库的Asio中设置connect超时和read超时的一种解决方案
猪少爷的专栏
09-04 8323
编写Asio中的同步或异步客户端时，库本身并没有提供超时机制，网上看了很多解决方案，看起来不是很简洁，想了一种思路，欢迎讨论 在使用同步client的时候，有时候会出现一种情况，可以成功打开客户端链接，但是数据发过去之后，很长时间收不到返回值，这个时候就会将进程或者线程阻住，影响其它业务的执行，所以想到用一个异步定时器，来控制超时，定时器代码实现如下： #pragma once #...
BOOST库学习之网络通信
qq_40223389的博客
11-05 2681
前言 本次笔记记录如下知识点 同步通信 异步通信 一、同步通信
boost::bind 详解
weixin_34227447的博客
10-08 736
使用 boost::bind是标准库函数std::bind1st和std::bind2nd的一种泛化形式。其可以支持函数对象、函数、函数指针、成员函数指针，并且绑定任意参数到某个指定值上或者将输入参数传入任意位置。 1. 通过functions和function pointers使用bind 给定如下函数： 1 int f(int a, int b) 2 { 3 retur...
boost进程间通信常用开发一篇全（消息队列，共享内存，信号）
固本培元的专栏
05-23 1万+
敏捷开发大家想必知道而且评价甚高，缩短开发周期，提高开发质量。将大工程独立为不同的小app开发，整个开发过程，程序可用可测，所以提高了整体的质量。基于这种开发模式和开发理念，进程间通信必然是童鞋们必掌握技能之一了，而boost库是众多库中平台支持性很好，效果很高之一。做嵌入式或者服务器等应用的人肯定有所涉及。本文以手册方式讲述boost共享内存，信号，以及消息队列的编程方式。很简单，列出最常用用法，供大家拷贝直接使用。本文出自优快云-固本培元。转载注明出处-leoluopy@gmail.com。
C++11 bind函数
热门推荐
青山绿水
10-23 1万+
bind函数的使用详解 可以将bind函数看作是一个通用的函数适配器，它接受一个可调用对象，生成一个新的可调用对象来“适应”原对象的参数列表。 调用bind的一般形式：auto newCallable = bind(callable,arg_list);` 其中，newCallable本身是一个可调用对象，arg_list是一个逗号分隔的参数列表，对应给定的callable的参数。即，当我们调用n......
boost库 bind/function的使用 [大三四八九月实习]
记一忘三二
09-03 1万+
1 bind/function 引 (1)头文件 bind函数#include /bind.hpp> function使用头文件#include 如果写程序时出错则在function及bind前面加上限定："boost::"   (2)功能 bind绑定一个函数及其参数. function是类和模板的组合，它定义的对象可以指向一个函数(包装一个函数 )，类似一个函数指针。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值