初识boost.asio库

boost安装教程

window跟着这个教程走，安装没问题
linux 自己百度一下就好了，教程蛮多的

啥也不说，咱们代码见

service_code

#include <boost/bind.hpp>
#include<boost/asio.hpp>
#include<boost/smart_ptr.hpp>
#include<iostream>
#include<queue>
using namespace boost::asio;
using ip::tcp;
using boost::system::error_code;
std::queue<std::string>q;


struct Service {
	Service(io_context &io_context) :ioService(io_context), acceptor(io_context, tcp::endpoint(tcp::v4(), 5055)) {}

	void start() {
		boost::shared_ptr<tcp::socket> socket_ptr(new tcp::socket(ioService));
		acceptor.async_accept(*socket_ptr, [socket_ptr,this](error_code ec) {
			if (ec) {
				std::cout << boost::system::system_error(ec).what() << std::endl;
			}
			else {
				std::cout << socket_ptr->remote_endpoint().address() << std::endl;
				read(socket_ptr);
				socket_ptr->write_some(buffer("hello world!\n"), ec);
			}
			start();
		});
	}

	void read(boost::shared_ptr<tcp::socket> socket_ptr) {
		socket_ptr->async_read_some(buffer(data_buffer, 6), [socket_ptr, this](error_code ec, size_t size) {
			if (ec) {
				std::cout << "async_read_some end!" << std::endl;
				while (!q.empty()) {
					std::cout << q.front();
					q.pop();
				}
				return;
			}
			else {
				std::cout << size << std::endl;
				std::cout.write(data_buffer, size);
				std::string s_data_buffer = data_buffer;
				q.push(s_data_buffer.substr(0, size));
				read(socket_ptr);
			}
		});
	}

private:
	io_context &ioService;
	ip::tcp::acceptor acceptor;
	char data_buffer[120];
};

int main() {
	io_context io_context;
	Service service(io_context);
	service.start();
	io_context.run();
	return 0;
}

client_code

#include<boost/smart_ptr.hpp>
#include<boost/asio.hpp>
#include<iostream>
#include<queue>
#include<string>
#include<thread>
using namespace boost::asio;
using boost::system::error_code;
using ip::tcp;
std::queue<std::string>q;
int n=1;
int m=1;

void write(boost::shared_ptr<tcp::socket> socket_ptr) {	
	if(q.empty())return;
	socket_ptr->async_write_some(buffer(q.front().data(), q.front().size()), [socket_ptr] (error_code ec , size_t size) {
			q.pop();
			if(!ec) {
				std::cout <<"this is "<< n++ << " n message\n";
				write(socket_ptr);	
			}
		});
	std::cout << "this is " << m++ << " m message\n";
}

void run() {
	q.push("hello\n");
	q.push("async\n");
	q.push("write\n");
	q.push("hello\n");
	q.push("hello\n");
	q.push("async\n");
	q.push("write\n");
	q.push("async\n");
	q.push("write\n");
	io_service io_service;
	tcp::endpoint ep(ip::address::from_string("ip_string"), 5055);
	boost::shared_ptr<tcp::socket> socket_ptr(new tcp::socket(io_service));
	socket_ptr->async_connect(ep, [socket_ptr](error_code ec) {
		if (ec) {
			return;
		}
		char data_buffer[100];
		write(socket_ptr);
		size_t buffer_size = socket_ptr->read_some(buffer(data_buffer), ec);
		if (ec) {
			return;
		}
		std::cout.write(data_buffer, buffer_size);
	});
	std::cout << "this is main thread \n"; 
	io_service.run();
	std::cout << "this is main thread \n"; 
}


int main() {
	std::thread thread1(run);
	thread1.join();
	// thread1.detach(); detach有个问题就是主线程结束会挂起子进程，从而得不到结果，可以添加一个输入等待子进程运行
}

简单意义解释

io_context io_context;// boost库核心类，必要，你在其他地方见到的io_service是一样的
// 官方文档 这样写的 typedef ypedef io_context io_service;
ip::tcp::acceptor acceptor; // 我把它理解为接受器，服务器端用，创建时必须给参数，他没有默认构造函数
// 创建一般时这样 acceptor（io_context,endpoint）;
tcp::endpoint ep// 端点 在服务器端使用ep（protocol,port）;用于被连接所以是协议
// 在客户端使用ep(address,port);发起连接，你需要知道对方的家庭住址
boost::shared_ptr<tcp::socket> socket_ptr(new tcp::socket(ioService));
// 定义智能指针
socket_ptr->aremote_endpoint().address() // 远程ip地址
read_some(buffer(char*),ec) // 接收数据
write_some(buffer(""),ec) // 写入数据
// 加async_就是异步，这是同步，异步需要绑定函数，我用的lambda函数
boost::system::error_code ec; // 用于接收错误，必要
// 差不多就这些了，对应着看应该能看懂简单的发送接收，

//ps： 异步操作必须绑定函数，我都是使用的lambda函数，如果不用lambda需要用bind()函数去绑定，我也没用过，百度一下全都是

lambada函数简单介绍

Lambda表达式完整的声明格式如下：
[capture list] (params list) mutable exception-> return type { function body }

各项具体含义如下:
	capture list：捕获外部变量列表
	params list：形参列表
	mutable指示符：用来说用是否可以修改捕获的变量
	exception：异常设定
	return type：返回类型
	function body：函数体
	
此外，我们还可以省略其中的某些成分来声明“不完整”的Lambda表达式，常见的有以下几种：
	[capture list] (params list) -> return type {function body}
	[capture list] (params list) {function body}
	[capture list] {function body}
其中：
	格式1声明了const类型的表达式，这种类型的表达式不能修改捕获列表中的值。
	格式2省略了返回值类型，但编译器可以根据以下规则推断出Lambda表达式的返回类型： 
		（1）：如果function body中存在return语句，则该Lambda表达式的返回类型由return语句的返回类型确定； 		
		（2）：如果function body中没有return语句，则返回值为void类型。
	格式3中省略了参数列表，类似普通函数中的无参函数。

捕获形式	说明
[]	不捕获任何外部变量
[变量名, …]	默认以值得形式捕获指定的多个外部变量（用逗号分隔），如果引用捕获，需要显示声明（使用&说明符）
[this]	以值的形式捕获this指针
[=]	以值的形式捕获所有外部变量
[&]	以引用形式捕获所有外部变量
[=, &x]	变量x以引用形式捕获，其余变量以传值形式捕获
[&, x]	变量x以值的形式捕获，其余变量以引用形式捕获

lambada 详细链接

PS: 欢迎萌新提问，我们共同探讨解决，我也是个纯新手，大佬路过欢迎指导

参考：https://www.cnblogs.com/DswCnblog/p/5629165.html