asio-1

准备看下asio的实现，就在win下搭建了。

准备仓库

git clone https://github.com/chriskohlhoff/asio.git

写CMakeLists.txt

cmake_minimum_required(VERSION 3.10)

project(StandaloneAsioExample)

set(CMAKE_CXX_STANDARD 14)
set(CMAKE_CXX_STANDARD_REQUIRED ON)

include_directories(${CMAKE_SOURCE_DIR}/asio/include)

add_definitions(-D_WIN32_WINNT=0x0601)
add_executable(StandaloneAsioExample main.cpp)
# target_link_libraries(StandaloneAsioExample pthread)

同步TCP服务

server

#include <iostream>
#include <asio.hpp>

using asio::ip::tcp;

void startServer() {
  try {
      asio::io_context io_context;
      tcp::acceptor acceptor(io_context, tcp::endpoint(tcp::v4(), 13));

      for (;;) {
          tcp::socket socket(io_context);
          acceptor.accept(socket);
          
          std::string message = "Hello from server!";
          asio::write(socket, asio::buffer(message));
      }
  } catch (std::exception& e) {
      std::cerr << "Exception: " << e.what() << "\n";
  }
}

int main() {
  startServer();
  return 0;
}

client

#include <iostream>
#include <asio.hpp>

using asio::ip::tcp;

void client() {
  try {
      asio::io_context io_context;
      tcp::resolver resolver(io_context);
      tcp::socket socket(io_context);
      asio::connect(socket, resolver.resolve("localhost", "13"));
      
      std::array<char, 128> buf;
      asio::error_code error;
      size_t len = socket.read_some(asio::buffer(buf), error);

      if (error == asio::error::eof)
          std::cout << "Connection closed cleanly by peer.\n";
      else if (error)
          throw std::system_error(error); // Some other error.

      std::cout.write(buf.data(), len);
  } catch (std::exception& e) {
      std::cerr << "Exception: " << e.what() << "\n";
  }
}

int main() {
  client();
  return 0;
}

异步TCP服务器

#include <iostream>
#include <asio.hpp>

using asio::ip::tcp;

class session : public std::enable_shared_from_this<session> {
public:
  session(tcp::socket socket) : socket_(std::move(socket)) {}

  void start() {
      do_read();
  }

private:
  void do_read() {
      auto self(shared_from_this());
      socket_.async_read_some(asio::buffer(data_, max_length),
          [this, self](std::error_code ec, std::size_t length) {
              if (!ec) {
                  std::cout << "Received: " << std::string(data_, length) << std::endl;
                  do_write(length);
              }
          });
  }

  void do_write(std::size_t length) {
      auto self(shared_from_this());
      asio::async_write(socket_, asio::buffer(data_, length),
          [this, self](std::error_code ec, std::size_t /*length*/) {
              if (!ec) {
                  do_read();
              }
          });
  }

  tcp::socket socket_;
  enum { max_length = 1024 };
  char data_[max_length];
};

class server {
public:
  server(asio::io_context& io_context, short port)
      : acceptor_(io_context, tcp::endpoint(tcp::v4(), port)) {
      do_accept();
  }

private:
  void do_accept() {
      acceptor_.async_accept(
          [this](std::error_code ec, tcp::socket socket) {
              if (!ec) {
                  std::make_shared<session>(std::move(socket))->start();
              }
              do_accept();
          });
  }

  tcp::acceptor acceptor_;
};

int main() {
  try {
      asio::io_context io_context;
      server s(io_context, 12345);
      io_context.run();
  } catch (std::exception& e) {
      std::cerr << "Exception: " << e.what() << "\n";
  }
  return 0;
}

timer

#include <iostream>
#include <asio.hpp>

void print(const asio::error_code& /*e*/,
  asio::steady_timer* t, int* count) {
  if (*count < 5) {
      std::cout << *count << std::endl;
      ++(*count);
      t->expires_at(t->expiry() + asio::chrono::seconds(1));
      t->async_wait(std::bind(print,
          std::placeholders::_1, t, count));
  }
}

int main() {
  asio::io_context io;

  int count = 0;
  asio::steady_timer t(io, asio::chrono::seconds(1));
  t.async_wait(std::bind(print,
      std::placeholders::_1, &t, &count));

  io.run();

  std::cout << "Final count is " << count << "\n";

  return 0;
}