BOOST库学习之网络通信

最新推荐文章于 2024-11-11 21:48:36 发布

南丶风.

最新推荐文章于 2024-11-11 21:48:36 发布

阅读量2.5k

点赞数 2

分类专栏： C++之BOOST库文章标签： c++

本文链接：https://blog.csdn.net/qq_40223389/article/details/121172839

版权

C++之BOOST库专栏收录该内容

8 篇文章 1 订阅

订阅专栏

本文详细介绍了Boost.ASIO库中的关键类，包括io_service、address、endpoint、socket、acceptor和tcp。通过实例展示了如何使用这些类进行同步通信，服务端创建并监听，客户端发起连接并接收数据。随后，文章转向异步通信，分别给出了服务端和客户端的异步实现，强调了回调函数在处理异步事件中的作用。

摘要由CSDN通过智能技术生成

前言

本次笔记记录如下知识点

通信核心类介绍
同步通信
异步通信

一、通信核心类介绍

1、io_service类

io_service类代表了系统里的异步处理机制，必须在asio库里的其他类之前进行初始化，它负责和操作系统打交道，等待所有异步操作的结束，然后为每一个异步操作调用其完成处理程序。

2、address类

address表示IP地址，可以同时支持IPV4和IPV6。

3、endpoint

通过IP地址和通信的端口号就可以构成一个socket端点。

4、socket类

socket类是TCP通信的基本类，主要用于接收数据和发送数据。

5、accepter类

accepter主要用于接受用户连接，用于服务端要配合socket使用。

6、tcp类

该类相当于一个命名空间，集合上上述中所有的类

二、同步通信

编写服务端

#include <iostream>
#include <boost/asio/ip/tcp.hpp>
#include <boost/asio/io_service.hpp>
using namespace std;
using namespace boost;

int main()
{
	try
	{
		//简化类型定义
		typedef boost::asio::ip::tcp::acceptor acceptor_type;
		typedef boost::asio::ip::tcp::endpoint endpoint_type;
		typedef boost::asio::ip::tcp::socket   socket_type;

		//io_service对象
		boost::asio::io_service io;

		//创建监听对象
		acceptor_type  acceptor(io, endpoint_type(boost::asio::ip::tcp::v4(), 8899));

		//循环执行服务
		for (;;)
		{
			//创建一个socket对象
			socket_type sock(io);

			//阻塞等待socket连接
			acceptor.accept(sock);

			cout << "client：";
			cout << sock.remote_endpoint().address() << endl;

			//发送数据
			sock.send(boost::asio::buffer("hello asio"));
		}
	}
	catch (const std::exception& e)
	{
		cout << e.what() << endl;
	}
}

编写客户端

#include <iostream>
#include <vector>
#include <boost/asio/ip/tcp.hpp>
#include <boost/asio/io_service.hpp>
using namespace std;
using namespace boost;

int main()
{
	try
	{
		//简化类型定义
		typedef boost::asio::ip::address       address_type;
		typedef boost::asio::ip::tcp::endpoint endpoint_type;
		typedef boost::asio::ip::tcp::socket   socket_type;

		// 创建 io_service对象
		boost::asio::io_service io;

		// 创建端点，用于连接
		endpoint_type ed(address_type::from_string("127.0.0.1"), 8899);

		//创建socket对象
		socket_type sock(io);

		//连接服务端
		sock.connect(ed);
		cout << sock.available() << endl;

		//定义一个缓冲区，使用buffer接受数据
		vector<char> str(sock.available() + 1, 0);
		sock.receive(boost::asio::buffer(str));

		//输出数据
		for (int i = 0; i < str.size(); i++)
		{
			cout << str[i] << endl;
		}
		int i = 0;
		cin >> i;
		
	}
	catch (const std::exception& e)
	{
		cout << e.what() << endl;
	}
}

三、异步通信

服务端

**TcpServer类 **

#pragma once

#include <boost/asio/ip/tcp.hpp>
#include <boost/asio/io_service.hpp>
#include <boost/shared_ptr.hpp>
#include <boost/bind.hpp>
#include <iostream>
using namespace std;
using namespace boost;

class TcpServer
{
	typedef   TcpServer								 this_type;
	typedef   boost::asio::ip::tcp::acceptor         acceptor_type;
	typedef   boost::asio::ip::tcp::endpoint		 endpoint_type;
	typedef   boost::asio::ip::tcp::socket			 socket_type;   
	typedef   boost::shared_ptr<socket_type>		 sock_ptr;      

private:
	boost::asio::io_service        m_io;
	acceptor_type                  m_acceptor;

public:
	//初始化端点以及开启监听
	TcpServer() :m_acceptor(m_io, endpoint_type(boost::asio::ip::tcp::v4(), 6688))
	{
		accept();
	}
	//启动异步监听
	void accept()
	{
		//创建通信的socket
		sock_ptr sock(new socket_type(m_io));
		//开启监听，并绑定回调函数Accept_Handler
		m_acceptor.async_accept(*sock, boost::bind(&this_type::Accept_Handler,
			this, boost::placeholders::_1, sock));
	}
	//
	void  run()
	{
		m_io.run();
	}
	//监听的回调函数
	void Accept_Handler(const boost::system::error_code& ec, sock_ptr sock)
	{
		//检查错误信息
		if (ec)
 		{
			return;
		}
		//再次开启回调函数
		accept();

		//显示客户端信息
		cout << "client :";
		cout << sock->remote_endpoint().address() << endl;

		//异步发送数据
		sock->async_write_some(boost::asio::buffer("hello asio"),
			bind(&this_type::Write_Handle, this, boost::placeholders::_1)
		);
	}
	//接受数据
	void  Write_Handle(const system::error_code&)
	{
		cout << "send msg complete" << endl;
	}
};

main主函数

#include <stdio.h>
#include "TcpServer.h"

int main()
{

	try
	{
		cout << " server start" << endl;
		TcpServer srv;
		//启动异步调用事件处理循环
		srv.run();
	}
	catch (std::exception& e)
	{
		cout << e.what() << endl;
	}
	return 0;
}

客户端

TcpClient

#pragma once
#include <boost/asio/ip/tcp.hpp>
#include <boost/asio/io_service.hpp>
#include <boost/shared_ptr.hpp>
#include <boost/bind.hpp>
#include <iostream>
#include <vector>
using namespace std;
using namespace boost;

class TcpClient
{
	typedef  TcpClient							this_type;
	typedef  boost::asio::ip::tcp::endpoint		endpoint_type;
	typedef  boost::asio::ip::address           address_type;
	typedef  boost::asio::ip::tcp::socket       socket_type;
	typedef  boost::shared_ptr<socket_type>     sock_ptr;
	typedef  vector<char>                       buffer_type;

private:
	boost::asio::io_service						m_io;
	buffer_type                                 m_buf;
	endpoint_type                               m_ep;

public:
	TcpClient() : m_buf(100, 0), m_ep(address_type::from_string("127.0.0.1"), 6688)
	{
		start();
	}

	// 启动异步监听
	void  run()
	{
		m_io.run();
	}

	void  start()
	{
		sock_ptr sock(new socket_type(m_io));
		//异步连接
		sock->async_connect(m_ep, bind(&this_type::conn_hadler, this, boost::placeholders::_1, sock));
	}
	//连接服务端 回调函数
	void conn_hadler(const boost::system::error_code& ec, sock_ptr sock)
	{
		if (ec)
		{
			return;
		}
		cout << "recive from" << sock->remote_endpoint().address() << endl;
		//绑定接受函数
		sock->async_read_some(boost::asio::buffer(m_buf), bind(&TcpClient::read_handler, this,
			boost::placeholders::_1));
	}

	void read_handler(const boost::system::error_code& ec)
	{
		if (ec)
		{
			return;
		}
		//输出接受的数据
		cout << &m_buf << endl;
	}

};

main主函数

#include <iostream>
#include "TcpClient.h"
using namespace std;


int main()
{
	try
	{
		cout << " client start" << endl;
		TcpClient srv;
		//启动异步调用事件处理循环
		srv.run();
	}
	catch (std::exception& e)
	{
		
		cout << e.what() << endl;
	}
}