boost学习之asio—chat

最新推荐文章于 2022-05-28 09:05:08 发布
最新推荐文章于 2022-05-28 09:05:08 发布
阅读量949 收藏 1
点赞数
分类专栏： boost 文章标签： boost asio C++ chat
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Pillary/article/details/53820839
版权

最近，工作从C切换到了C++，项目中大量用到Boost，就开始进行相关的boost学习，下面是参考boost example实现的chat。基于asio的tcp。

Talk is cheap. Show me the code.


1、简单的消息封装格式（Header＋Body），Header为4个字节，为body的长度；Body可为任意字符串。

//
//  JfyChatMessage.hpp
//  TestRunner
//
//  Created by zhaipillary on 16/12/21.
//  Copyright © 2016年 zhaipillary. All rights reserved.
//

#ifndef JfyChatMessage_h
#define JfyChatMessage_h

#include <cstdio>
#include <cstdlib>
#include <cstring>

//移除文件目录
#ifdef WIN32
#define TrimFilePath(x) strrchr(x,'\\')?strrchr(x,'\\')+1:x
#else //*nix
#define TrimFilePath(x) strrchr(x,'/')?strrchr(x,'/')+1:x
#endif

//简单日志封装，打印到屏幕上
#define LogDebug(fmt, ...)   \
printf("[DEBUG] [%s(%d)] : " fmt"\n",TrimFilePath(__FILE__),__LINE__,##__VA_ARGS__)
#define LogInfo(fmt, ...)    \
printf("[INFO ] [%s(%d)] : " fmt"\n",TrimFilePath(__FILE__),__LINE__,##__VA_ARGS__)
#define LogWarn(fmt, ...)    \
printf("[WARN ] [%s(%d)] : " fmt"\n",TrimFilePath(__FILE__),__LINE__,##__VA_ARGS__)
#define LogError(fmt, ...)   \
printf("[ERROR] [%s(%d)] : " fmt"\n",TrimFilePath(__FILE__),__LINE__,##__VA_ARGS__)



class CChatMessage
{
public:
    enum { MSG_HEADER_LEN = 4 };
    enum { MSG_BODY_LEN_MAX = 512 };
    
public:
    CChatMessage()
    {
        Clear();
    }
    
    const char* GetData() const
    {
        return m_szData;
    }
    
    char* GetData()
    {
        return m_szData;
    }
    
    size_t Length() const
    {
        return (MSG_HEADER_LEN + m_nBodyLen);
    }
    
    const char* GetBody() const
    {
        return m_szData + MSG_HEADER_LEN;
    }
    
    char* GetBody()
    {
        return m_szData + MSG_HEADER_LEN;
    }
    
    size_t BodyLength() const
    {
        return m_nBodyLen;
    }
    
    void BodyLength(size_t nNewLen)
    {
        m_nBodyLen = (nNewLen > MSG_BODY_LEN_MAX) ? MSG_BODY_LEN_MAX : nNewLen;
    }
    
    void Clear()
    {
        m_nBodyLen = 0;
        memset(m_szData,0,(MSG_HEADER_LEN+MSG_BODY_LEN_MAX));
    }
    
    bool DecodeHeader()
    {
        char szHeader[MSG_HEADER_LEN+1] = {0};
        std::strncat(szHeader,m_szData,MSG_HEADER_LEN);
        
        m_nBodyLen = std::atoi(szHeader);
        if(m_nBodyLen > MSG_BODY_LEN_MAX)
        {
            LogError("%s,BodyLen[%lu]>MaxLen[%d]",__FUNCTION__,m_nBodyLen,MSG_BODY_LEN_MAX);
            m_nBodyLen = 0;
            return false;
        }
        
        return true;
    }
    
    void EncodeHeader()
    {
        char szHeader[MSG_HEADER_LEN+1] = {0};
        std::sprintf(szHeader,"%4d",static_cast<int>(m_nBodyLen));
        std::memcpy(m_szData,szHeader,MSG_HEADER_LEN);
    }
    
private:
    char m_szData[MSG_HEADER_LEN+MSG_BODY_LEN_MAX];
    size_t m_nBodyLen;

};


#endif /* JfyChatMessage_h */

 


 
 

2、Client端代码
 

 

//
//  JfyChatClient.hpp
//  TestRunner
//
//  Created by zhaipillary on 16/12/21.
//  Copyright © 2016年 zhaipillary. All rights reserved.
//

#ifndef JfyChatClient_h
#define JfyChatClient_h


#include "JfyChatMessage.hpp"

#include <boost/asio.hpp>
#include <boost/bind.hpp>
#include <boost/thread/thread.hpp>

#include <deque>
#include <iostream>

#include <cstdlib>

using namespace std;

using boost::asio::ip::tcp;

typedef deque<CChatMessage> ChatMsgQue;

class CChatClient
{
public:
    CChatClient(boost::asio::io_service& ios,tcp::endpoint ep)
    : m_ios(ios),m_socket(ios)
    {
        m_socket.async_connect(
                               ep,
                               boost::bind(&CChatClient::HandlerConnect,
                                           this,
                                           boost::asio::placeholders::error) );
    }
    
    void Write(const CChatMessage& msg)
    {
        LogInfo("send msg[%lu]:%s",msg.BodyLength(),msg.GetBody() );
        
        m_ios.post(boost::bind(&CChatClient::DoWrite,this,msg));
    }
    
    void Close()
    {
        m_ios.post(boost::bind(&CChatClient::DoClose,this) );
    }
    
private:
    void HandlerConnect(const boost::system::error_code& ec)
    {
        if(!ec)
        {
            LogInfo("connect server:[%s:%d]",
                    m_socket.remote_endpoint().address().to_string().c_str(),
                    m_socket.remote_endpoint().port() );
            
            boost::asio::async_read(m_socket,
                                    boost::asio::buffer(m_msgRead.GetData(),
                                                        CChatMessage::MSG_HEADER_LEN),
                                    boost::bind(&CChatClient::HandlerRead,
                                                this,
                                                boost::asio::placeholders::error) );
        }
        else
        {
            LogError("%s errorCode[%d]:%s",__FUNCTION__,ec.value(),ec.message().c_str());
        }
        
    }
    
    void HandlerRead(const boost::system::error_code& ec)
    {
        if (!ec && m_msgRead.DecodeHeader() )
        {
            boost::asio::async_read(m_socket,
                                    boost::asio::buffer(m_msgRead.GetBody(),
                                                        m_msgRead.BodyLength()),
                                    boost::bind(&CChatClient::HandlerReadBody,
                                                this,
                                                boost::asio::placeholders::error) );
        }
        else
        {
            LogError("%s errorCode[%d]:%s",__FUNCTION__,ec.value(),ec.message().c_str());
            DoClose();
        }
        
    }
    
    void HandlerReadBody(const boost::system::error_code& ec)
    {
        if(!ec)
        {
            LogInfo("recv msg[%lu]:%s",m_msgRead.BodyLength(),m_msgRead.GetBody() );
            
            m_msgRead.Clear();
            
            boost::asio::async_read(m_socket,
                                    boost::asio::buffer(m_msgRead.GetData(),
                                                        CChatMessage::MSG_HEADER_LEN),
                                    boost::bind(&CChatClient::HandlerRead,
                                                this,
                                                boost::asio::placeholders::error) );
        }
        else
        {
            LogError("%s errorCode[%d]:%s",__FUNCTION__,ec.value(),ec.message().c_str());
            DoClose();
        }
        
    }
    
    void HandlerWrite(const boost::system::error_code& ec)
    {
        if (!ec)
        {
            m_msgWrite.pop_front();
            if (!m_msgWrite.empty())
            {
                boost::asio::async_write(m_socket,
                                         boost::asio::buffer(m_msgWrite.front().GetData(),
                                                             m_msgWrite.front().Length() ),
                                         boost::bind(&CChatClient::HandlerWrite,
                                                     this,
                                                     boost::asio::placeholders::error) );
            }
        }
        else
        {
            LogError("%s errorCode[%d]:%s",__FUNCTION__,ec.value(),ec.message().c_str());
            DoClose();
        }
    }
    
    void DoWrite(CChatMessage msg)
    {
        bool bWrite = !m_msgWrite.empty();
        m_msgWrite.push_back(msg);
        
        if(!bWrite)
        {
            boost::asio::async_write(m_socket,
                                     boost::asio::buffer(m_msgWrite.front().GetData(),
                                                         m_msgWrite.front().Length() ),
                                     boost::bind(&CChatClient::HandlerWrite,
                                                 this,
                                                 boost::asio::placeholders::error) );
        }
    }
    
    void DoClose()
    {
        LogInfo("chat client do close");
        m_socket.close();
    }
    
private:
    boost::asio::io_service& m_ios;
    tcp::socket m_socket;
    CChatMessage m_msgRead;
    ChatMsgQue m_msgWrite;
};


int ChatClientRun(string strIp,unsigned short nPort)
{
    LogInfo("Begin %s",__FUNCTION__);
    try
    {
        boost::asio::io_service ios;
        tcp::endpoint ep(boost::asio::ip::address::from_string(strIp),nPort);
        
        CChatClient client(ios,ep);
        boost::thread thr(boost::bind(&boost::asio::io_service::run,&ios));
        
        char szText[CChatMessage::MSG_BODY_LEN_MAX+1] = {0};
        while (cin.getline(szText,CChatMessage::MSG_BODY_LEN_MAX) )
        {
            CChatMessage msg;
            msg.BodyLength(strlen(szText));
            memcpy(msg.GetBody(),szText,msg.BodyLength());
            msg.EncodeHeader();
            client.Write(msg);
            memset(szText,0,sizeof(szText));
        }
        
        client.Close();
        thr.join();
    }
    catch (std::exception& e)
    {
        LogError("%s Exception :%s",__FUNCTION__,e.what());
        return -1;
    }
    
    
    return 0;
}


#endif /* JfyChatClient_h */

 

 

  

 

3、Server端代码
 

 

//
//  JfyChatServer.hpp
//  TestRunner
//
//  Created by zhaipillary on 16/12/21.
//  Copyright © 2016年 zhaipillary. All rights reserved.
//

#ifndef JfyChatServer_h
#define JfyChatServer_h

#include "JfyChatMessage.hpp"

#include <boost/asio.hpp>
#include <boost/bind.hpp>
#include <boost/shared_ptr.hpp>
#include <boost/enable_shared_from_this.hpp>

#include <set>
#include <list>
#include <deque>
#include <algorithm>
#include <iostream>

#include <cstdlib>

using namespace std;


using boost::asio::ip::tcp;

class CChatParticipant;
class CChatSession;
typedef deque<CChatMessage> ChatMsgQue;

typedef boost::shared_ptr<CChatParticipant> ChatPartPtr;
typedef boost::shared_ptr<CChatSession> ChatSessionPtr;

class CChatParticipant
{
public:
    virtual ~CChatParticipant() {};
    virtual void Deliver(const CChatMessage& msg) = 0;
};


class CChatRoom
{
public:
    void Join(ChatPartPtr part)
    {
        LogInfo("part[%p] join room",&part);
        
        m_setParts.insert(part);
        for_each(m_queMsg.begin(), m_queMsg.end(),
                 boost::bind(&CChatParticipant::Deliver,part,_1) );
    }
    
    void Leave(ChatPartPtr part)
    {
        LogInfo("part[%p] leave room",&part);
        m_setParts.erase(part);
    }
    
    void Deliver(const CChatMessage& msg)
    {
        LogInfo("ChatRoom Deliver msg[%lu]:%s",msg.BodyLength(),msg.GetBody());
        
        m_queMsg.push_back(msg);
        while(m_queMsg.size() > MAX_RECENT_MSG_NUM )
        {
            m_queMsg.pop_front();
        }
        
        for_each(m_setParts.begin(), m_setParts.end(),
                 boost::bind(&CChatParticipant::Deliver,_1,boost::ref(msg) ) );
    }
    
private:
    set<ChatPartPtr> m_setParts;
    ChatMsgQue m_queMsg;
    
private:
    enum { MAX_RECENT_MSG_NUM = 100 };
};

class CChatSession
: public CChatParticipant,public boost::enable_shared_from_this<CChatSession>
{
    
public:
    CChatSession(boost::asio::io_service& ios,CChatRoom& room)
    : m_socket(ios),m_room(room)
    {
    }
    
    tcp::socket& Socket()
    {
        return m_socket;
    }
    
    void Start()
    {
        m_room.Join(shared_from_this());
        
        boost::asio::async_read(m_socket,
                                boost::asio::buffer(m_msgRead.GetData(),
                                                    CChatMessage::MSG_HEADER_LEN),
                                boost::bind(&CChatSession::HandlerRead,
                                            shared_from_this(),
                                            boost::asio::placeholders::error));
    }
    
    void Deliver(const CChatMessage& msg)
    {
        bool bWrite = !m_msgWrite.empty();
        m_msgWrite.push_back(msg);
        
        if(!bWrite)
        {
            boost::asio::async_write(m_socket,
                                     boost::asio::buffer(m_msgWrite.front().GetData(),
                                                         m_msgWrite.front().Length()),
                                     boost::bind(&CChatSession::HandlerWrite,
                                                 shared_from_this(),
                                                 boost::asio::placeholders::error) );
        }
    }
    
private:
    void HandlerRead(const boost::system::error_code& ec)
    {
        if(!ec && m_msgRead.DecodeHeader())
        {
            boost::asio::async_read(m_socket,
                                     boost::asio::buffer(m_msgRead.GetBody(),
                                                         m_msgRead.BodyLength()),
                                     boost::bind(&CChatSession::HandlerReadBody,
                                                 shared_from_this(),
                                                 boost::asio::placeholders::error) );
        }
        else
        {
            LogError("%s errorCode[%d]:%s",__FUNCTION__,ec.value(),ec.message().c_str());
            m_room.Leave(shared_from_this());
        }
    }
    
    void HandlerReadBody(const boost::system::error_code& ec)
    {
        if (!ec)
        {
            LogInfo("receive client:[%s:%d],msg[%lu]:%s",
                    m_socket.remote_endpoint().address().to_string().c_str(),
                    m_socket.remote_endpoint().port(),
                    m_msgRead.BodyLength(),
                    m_msgRead.GetBody() );
            
            m_room.Deliver(m_msgRead);
            boost::asio::async_read(m_socket,
                                    boost::asio::buffer(m_msgRead.GetData(),
                                                        CChatMessage::MSG_HEADER_LEN),
                                    boost::bind(&CChatSession::HandlerRead,
                                                shared_from_this(),
                                                boost::asio::placeholders::error));
        }
        else
        {
            LogError("%s errorCode[%d]:%s",__FUNCTION__,ec.value(),ec.message().c_str());
            m_room.Leave(shared_from_this());
        }
        
    }
    
    void HandlerWrite(const boost::system::error_code& ec)
    {
        if(!ec)
        {
            m_msgWrite.pop_front();
            if (!m_msgWrite.empty())
            {
                boost::asio::async_write(m_socket,
                                         boost::asio::buffer(m_msgWrite.front().GetData(),
                                                             m_msgWrite.front().Length()),
                                         boost::bind(&CChatSession::HandlerWrite,
                                                     shared_from_this(),
                                                     boost::asio::placeholders::error));
            }
        }
        else
        {
            m_room.Leave(shared_from_this());
            LogError("%s errorCode[%d]:%s",__FUNCTION__,ec.value(),ec.message().c_str());
        }
    }
    
private:
    tcp::socket m_socket;
    CChatRoom& m_room;
    CChatMessage m_msgRead;
    ChatMsgQue m_msgWrite;
};

class CChatServer
{
public:
    CChatServer(boost::asio::io_service& ios,const tcp::endpoint& ep)
    :m_ios(ios),m_acceptor(ios,ep)
    {
        Start();
    }
    
private:
    void Start()
    {
        ChatSessionPtr session(new CChatSession(m_ios,m_room));
        
        m_acceptor.async_accept(session->Socket(),
                                boost::bind(&CChatServer::HandlerAccept,
                                            this,
                                            session,
                                            boost::asio::placeholders::error));
    }
    
    void HandlerAccept(ChatSessionPtr session, const boost::system::error_code& ec)
    {
        if (!ec)
        {
            LogInfo("accept client:[%s:%d]",
                    session->Socket().remote_endpoint().address().to_string().c_str(),
                    session->Socket().remote_endpoint().port() );
            
            session->Start();
        }
        else
        {
            LogError("%s errorCode[%d]:%s",__FUNCTION__,ec.value(),ec.message().c_str());
        }
        
        Start();
    }
    
private:
    boost::asio::io_service& m_ios;
    tcp::acceptor m_acceptor;
    CChatRoom m_room;
};


int ChatServerRun(unsigned short nPort)
{
    LogInfo("Begin %s",__FUNCTION__);
    try
    {
        boost::asio::io_service ios;
        tcp::endpoint ep(tcp::v4(),nPort);
        CChatServer server(ios,ep);
        
        ios.run();
        
    }
    catch (std::exception& e)
    {
        LogError("%s Exception :%s",__FUNCTION__,e.what());
        return -1;
    }
    
    return 0;
}


#endif /* JfyChatServer_h */

 

 
4、Main函数代码 

 

//
//  main.cpp
//  TestRunner
//
//  Created by zhaipillary on 16/12/21.
//  Copyright © 2016年 zhaipillary. All rights reserved.
//

//#include "JfyLog.h"

#include "JfyChatServer.hpp"
#include "JfyChatClient.hpp"



int main(int argc, char* argv[])
{
    LogInfo("Begin working !");
    

    if (2 == argc && 0 == strncmp("client",argv[1],6))
    {
        ChatClientRun("127.0.0.1", 12345);
    }
    else
    {
        ChatServerRun(12345);
    }


    LogInfo("End %s",__FUNCTION__);
    return 0;
}

 

 

 


                

        

        

    

  


    

      

        

            

              
                
                  沐寒握冰
                
              
            

            

                关注
              
            

        

        

          
      

      

            

                专栏目录
          









                



	

		

			

				
					
boost---chat(聊天室框架)

				
			

			

				

					小米的修行之路
				

				

					09-18
					
					863
					
				

			

		

		

			
				
程序改自boost官方的聊天室程序，改动不是很大。程序逻辑虽然简单，但是仍有很大的价值值得我们好好学习一下：

1、服务端：

（1）chat_server.cpp


// chat_server.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。
//

#include "pch.h"
#include "chat_room.h"
#include "chat_sess...

			
		

	



                

              
                



	

		

			

				
					
Boost：基于Boost的聊天的应用程序

				
			

			

				

					希望我的博客，能帮上你解决学习中工作中所遇到的问题
				

				

					05-22
					
					297
					
				

			

		

		

			
				
Boost：基于Boost的chat应用程序实现功能C++实现代码客户端源码服务端源码
实现功能
基于Boost的chat应用程序
C++实现代码
客户端源码
#include <cstdlib>
#include <deque>
#include <iostream>
#include <boost/bind/bind.hpp>
#include <boost/asio.hpp>
#include <boost/thread/thread.

			
		

	



                


  
              

                


	

		

			

				
					
Boost.Asio学习之实现广播ChatRoom

				
			

			

				

					上善若水
				

				

					01-10
					
					2161
					
				

			

		

		

			
				
boost.asio之实现聊天服务器

			
		

	





	

		

			

				
					
boost::asio学习之[六]简单聊天程序

				
			

			

				

					yanziguilai的专栏
				

				

					04-16
					
					1204
					
				

			

		

		

			
				
#pragma once
#include 
#include 
#include 

namespace ChatTest
{
	class chat_message
	{
	public:
		enum {header_length = 4, max_body_length = 1024};
	public:
		chat_message() : body_length_(0) {}

		s

			
		

	



		

			
		



	

		

			

				
					
asio聊天室服务器(C++asio网络库相关）

				
			

			

				

					昔拉的博客
				

				

					01-23
					
					1122
					
				

			

		

		

			
				
以下是根据asio官方库改写的一个例子：
//main.cpp
#include "chat_message.h"

#include <boost/asio.hpp>

#include <deque>
#include <iostream>
#include <list>
#include <memory>
#include <...

			
		

	





	

		

			

				
					
boost asio异步读写网络聊天程序客户端 实例详解

				
			

			

				

					Think88666的博客
				

				

					05-12
					
					567
					
				

			

		

		

			
				
boost官方文档中聊天程序实例讲解

数据包格式chat_message.hpp

<pre name="code" class="cpp"><h3>数据包chat_message.hpp</h3>
// chat_message.hpp
// ~~~~~~~~~~~~~~~~
//
// Copyright (c) 2003-2013 Christopher...

			
		

	





	

		

			

				
					
asio_chat_client.rar_ASIO_Boost_asio chat_boost.asio

				
			

			

				

					09-23
				

			

		

		

			
				
ASIO库是Boost库的一部分，...通过学习和分析这个“asio_chat_client”示例，你可以深入理解Boost.ASIO如何简化网络编程，以及如何利用异步I/O实现高性能的客户端应用。同时，这也是提升C++网络编程技能的一个好方法。

			
		

	





	

		

			

				
					
VScode CMake 编写 Boost Asio Chat程序----记录6

				
			

			

				

					m0_68696793的博客
				

				

					05-28
					
					372
					
				

			

		

		

			
				
目录

一 前言

二参考

三 程序

四 解读

五 注意事项



一 前言



二参考

1 源程序:C++03 Examples - 1.79.0



2 参考: 找不到原始文件了, 谢谢原作者, 请这样在本站这样搜索:





三 程序

四 解读

五 注意事项
...

			
		

	





	

		

			

				
					
boost::asio学习之[七] buffer

				
			

			

				

					yanziguilai的专栏
				

				

					04-17
					
					1510
					
				

			

		

		

			
				
boost::asio学习 - buffer篇




boost::asio::streambuf
使用read_until() 和 async_read_until()读取line-based（使用"\r\n"或者其它自定义字符序列作为delimiter）数据时需要boost::asio::streambuf来缓存读取到的数据。
下面是boost文档中的read_unitl()示

			
		

	





	

		

			

				
					
boost.asio 代码 侯捷_-_Boost_技术与应用.pdf

				
			

			

				

					11-10
				

			

		

		

			
				
侯捷老师的《Boost 技术与应用》一书深入浅出地介绍了 Boost 库，其中对 Boost.Asio 的讲解尤为详尽，对于学习 C++ 网络编程的开发者来说是一份宝贵的资源。  **1. 异步 I/O**：Boost.Asio 的核心概念是异步 I/O ...

			
		

	





	

		

			

				
					
chat:使用Boost的异步客户端-服务器聊天应用程序

				
			

			

				

					04-11
				

			

		

		

			
				
客户端-服务器应用程序：简单聊天
关于：
 使用boost :: asio库在C ++（std :: c ++ 17）上编写的异步客户端服务器聊天记录。
目标：
 为了使数据交换正式化，服务器可以实现一个API
 定义特定的内容格式
解析它。
 调度系统以区分来自客户端的传入请求的优先级以适应它们
为了防止滥用和最大化可用性，服务器软件可能会限制客户端的可用性（再次受到DoS攻击）
 如果要在客户端和服务器之间传递敏感信息，则应使用加密。
 将使用TCP协议。
完毕
 从客户端读取数据
 将读取的数据传递到服务器
 向所有客户广播接收到的数据
 及时删除所有已关闭的连接
待办事项＃1
 添加安全的客户端断开连接
 添加安全的服务器断开连接应该通过捕获io_context中的异常来实现安全断开连接，因此需要将其包装在try-catch块中。
 修复错误并增加多线程安全性：
并发执行访问同一套

			
		

	





	

		

			

				
					
chat-server：使用boost.asio的简单聊天服务器示例

				
			

			

				

					02-15
				

			

		

		

			
				
简单的聊天应用程序示例。
动机
该代码无意在生产环境中使用，并且主要出于个人教育目的而编写。 因此，构建管道和开发环境可能对于当前项目的规模而言是过大的，但是可以用作具有类似目标的大型项目的起始模板。
服务器
功能性
每个服务器应具有一个聊天室的实例
聊天室应包含当前活动参与者的全部内容，这是活动会话的一种。
 创建新会话时，服务器应提示并存储每个参与者的名称。
 广播聊天消息时，应首先打印消息所有者的姓名。
 当前构建的快速概述：
客户
在当前阶段，尚无客户端构建； 使用netcat工具测试并连接到聊天服务器。
用法
发展
该环境包含一个.devcontainer文件夹，该文件夹包含使用vscode在Docker容器实例内部开发应用程序的配置。
 确保已安装扩展，然后按CTRL + SHIFT + P。 这将打开vscode命令窗口。 进入
>Remote-Containers: Reo

			
		

	





	

		

			

				
					
doc / html / boost_asio / example / chat / chat_client.cpp

				
			

			

				

					xupeng1644的博客
				

				

					04-04
					
					1408
					
				

			

		

		

			
				
doc / html / boost_asio / example / chat / chat_client.cpp
// chat_client.cpp
// ~~~~~~~~~~~~~~~
//
// Copyright (c) 2003-2010 Christopher M. Kohlhoff (chris at kohlhoff dot com)
//
// Distributed und...

			
		

	





	

		

			

				
					
利用boost:asio写的简单聊天服务器四

				
			

			

				

					hkm_best的专栏
				

				

					12-05
					
					988
					
				

			

		

		

			
				
二、客户端源代码
1. ChatClient.cpp （客户端main）
#include 
#include 
#include 
#include 
#include 
#include 

using namespace boost::asio::ip;
using namespace std;


class CClient
{
public:
	CClient(boost::asio

			
		

	





	

		

			

				
					
利用boost:asio写的简单聊天服务器三

				
			

			

				

					hkm_best的专栏
				

				

					12-05
					
					1170
					
				

			

		

		

			
				
一、服务器端源代码
5. Server.cpp  （侦听端口，接收连接，创建新CCnection）
#include "Server.h"
#include "ConnectionManager.h"
#include 
#include 

using namespace std;

CServer * CServer::sm_instance=NULL;

CServer * CServe

			
		

	





	

		

			

				
					
boost asio异步读写网络聊天室【官方示例】

				
			

			

				

					永无止境
				

				

					12-20
					
					3484
					
				

			

		

		

			
				
//
// chat_message.hpp
// ~~~~~~~~~~~~~~~~
//
// Copyright (c) 2003-2010 Christopher M. Kohlhoff (chris at kohlhoff dot com)
//
// Distributed under the Boost Software License, Version 1.0. (See accom

			
		

	





	

		

			

				
					
boost.asio源码阅读(1) - 从chat_server开始

				
			

			

				

					weixin_30586085的博客
				

				

					03-20
					
					138
					
				

			

		

		

			
				
1. 关于示例代码 chat
先从简单的入手，
在如下路径：boost_1_63_0/libs/asio/example/cpp11/chat中找到chat_server.cpp
查看其成员，
private:
tcp::acceptor acceptor_;
tcp::socket socket_;
仅关注上述两个即可，其它的请自动忽略，在本文中不相关。使用过asio的都知道，io_servic...

			
		

	





	

		

			

				
					
boost入门（二）：Asio的编译

				
			

			

				

					q893332169的博客
				

				

					04-19
					
					4058
					
				

			

		

		

			
				
前言
经过上一篇文章《boost入门：boost简介》，我们编译了boost库。下面我们学习下Asio。
Asio是不需要编译成lib文件，直接在程序中引入头文件即可。Asio依赖的库比较多，我们可以看下它的依赖：


Boost.System（必须）


Boost.Coroutine（可选），如果用spawn()启动协程就需要它


Boost.Regex（可选），如果使用带参数的read_until()或async_read_until()重载boost::regex


OpenSSL（可选），如果

			
		

	





	

		

			

				
					
配置中心.zip

					
最新发布

				
			

			

				

					09-24
				

			

		

		

			
				
配置中心

			
		

	





	

		

			

				
					
Boost.Asio库编程指南

				
			

			

				

					
				

			

		

		

			
				
"《Boost.Asio库编程》是...通过学习和掌握Boost.Asio库，你可以构建出高效、可靠的网络应用，无论是简单的通信服务还是复杂的分布式系统。它为C++开发者提供了一把强大的工具，使得网络编程变得更加简单和高效。

			
		

	



              




          




        



    





    



      

      

        
      

      





	

		
评论 1

	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

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

              

            

          

      

      余额充值