同步读写

boost::asio提供了几种同步写的api 异步用的比较少的是send和receive

同步写

write_some

write_some可以每次向指定的空间写入固定的字节数，如果写缓冲区满了，就只写一部分，返回写入的字节数。

sock.write_some(buf,25),每次写buf中的25个子到sock,满了则返回写入的字节数

void write_to_socket(asio::ip::tcp::socket& sock) {
	std::string buf = "HELLO,WORLD";
	//已近写入的字数
	//size_t近似无符号的整型
	std::size_t total_bytes_written = 0;
	//循环发送
	//write_some返回每次写入的字数
	while (total_bytes_written != buf.length()) {
		//从buf首字母开始通过buffer（）
		// 但不是每次都从首字母
		//没发完的话就要从原先首字母位置-已经发出去的字数，的位置开始
		//write_some( , )后一个参数传每次写入的字数
		total_bytes_written += sock.write_some(asio::buffer(buf.c_str() + total_bytes_written
			, buf.length() - total_bytes_written));
	}
}

//客户端发送数据伪代码
int send_data_by_send() {
	std::string raw_ip_address = "192.168.3.11";
	unsigned short port_num = 3333;
	try {
		asio::ip::tcp::endpoint
			ep(asio::ip::address::from_string(raw_ip_address),
				port_num);
		asio::io_context ios;
		//创建sock，连接到对端上
		asio::ip::tcp::socket sock(ios, ep.protocol());
		sock.connect(ep);

		//连接好之后开始传数据
		write_to_socket(sock);
		//这是同步的方式，但我们没有必要轮询每次发一点，
		// 是在异步才需要更多的          

	}
	catch (system::system_error& e) {
		std::cout << "Error occured! Error code = " << e.code()
			<< ". Message: " << e.what();

		return e.code().value();
	}
	return 0;
}

TCP内核态与用户态不匹配的原因： 我只能发7个，剩下五个发不了，write_some()返回7 用户要发的数量与tcp能发的数量不匹配，

send

从上述代码可以看出要发完的话，很麻烦。

send函数会一次性将buffer中的内容发送给对端，如果有部分字节因为发送缓冲区满无法发送，则阻塞等待，直到发送缓冲区可用，则继续发送完成。

		sock.connect(ep);
		std::string buf = "HELLo";
		//我就让你发这么多，发不完也别告诉我
		//发完再告诉我
		int send_length=sock.send(asio::buffer(buf.c_str(), buf.length()));
		//send_length<0
		//说明sock系统级的错误
		//==0说明对端关闭
		//>0这个buf的长度
		if (send_length <= 0) {
			return 0;
		}
	}

write

与send类似，不过是asio里面的一个全局函数

		sock.connect(ep);
		std::string buf = "HELLo";
		
		int send_length = 
                asio::write(sock, asio::buffer(buf.c_str(), buf.length()));
		
		if (send_length <= 0) {
			return 0;
		}

同步读

read_some

std::string read_from_socket(asio::ip::tcp::socket& sock) {
	//消息的长度
	const unsigned char MESSAGE_SIZE = 7;
	char buf[MESSAGE_SIZE];
	//每次读后我们读到的字节数
	std::size_t total_bytes_read = 0;
	//不为7一直读，直到读满buf数组
	while (total_bytes_read != MESSAGE_SIZE) {
		total_bytes_read += sock.read_some(asio::buffer(buf + total_bytes_read,
			MESSAGE_SIZE - total_bytes_read));
	}
	return std::string(buf, total_bytes_read);
}

客户端去读的伪代码

//伪代码
int read_data_by_read_some() {
	std::string raw_ip_address = "127.0.0.1";
	unsigned short port_num = 3333;
	try {
		asio::ip::tcp::endpoint
			ep(asio::ip::address::from_string(raw_ip_address),
				port_num);
		asio::io_context ios;
		asio::ip::tcp::socket sock(ios, ep.protocol());
		sock.connect(ep);
		read_from_socket(sock);

	}
	catch (system::system_error& e) {
		std::cout << "Error occured! Error code = " << e.code()
			<< ". Message: " << e.what();

		return e.code().value();
	}
	return 0;
}

还是要循环读，太麻烦，此时可用receive

receive

		sock.connect(ep);

		const unsigned char BUFF_SIZE = 7;
		char buffer_receive[BUFF_SIZE];
		//调这个函数返回读满的数
		int receive_length = sock.receive(asio::buffer(buffer_receive,BUFF_SIZE));
		if (receive_length <= 0) {
			std::cout << "receive failed" << std::endl;
		}

类似的还有read,是一个asio里面的全局函数

read

		sock.connect(ep);

		const unsigned char BUFF_SIZE = 7;
		char buffer_receive[BUFF_SIZE];
		//调这个函数返回读满的数
		int receive_length = asio::read(sock,asio::buffer(buffer_receive,BUFF_SIZE));
		if (receive_length <= 0) {
			std::cout << "receive failed" << std::endl;
		}

拓展

读取到指定字符 我们可以一直读取，直到读取指定字符结束

std::string  read_data_by_until(asio::ip::tcp::socket& sock) {
    asio::streambuf buf;

    // Synchronously read data from the socket until
    // '\n' symbol is encountered.  
    asio::read_until(sock, buf, '\n');

    std::string message;

    // Because buffer 'buf' may contain some other data
    // after '\n' symbol, we have to parse the buffer and
    // extract only symbols before the delimiter. 

    std::istream input_stream(&buf);
    std::getline(input_stream, message);
    return message;
 }