C++使用BOOST中的IOCP给出一套客户端服务器源码示例

源码资源网

C++使用BOOST中的IOCP给出一套客户端服务器源码示例
以下是一个基于 Boost.Asio 和 IOCP（I/O Completion Port）的简单客户端-服务器示例。Boost.Asio 是一个跨平台的 C++ 库，提供了异步 I/O 操作的支持，而在 Windows 平台上，Boost.Asio 底层使用了 IOCP 来实现高效的异步 I/O。

---

### 服务器端代码

服务器端使用 Boost.Asio 监听客户端连接，并异步接收和发送数据。

```cpp
#include <boost/asio.hpp>
#include <iostream>
#include <memory>
#include <thread>
#include <vector>

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

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

    void Start()
    {
        DoRead();
    }

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

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

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

class Server
{
public:
    Server(boost::asio::io_context& io_context, short port)
        : acceptor_(io_context, tcp::endpoint(tcp::v4(), port))
    {
        DoAccept();
    }

private:
    void DoAccept()
    {
        acceptor_.async_accept(
            [this](boost::system::error_code ec, tcp::socket socket)
            {
                if (!ec)
                {
                    std::cout << "New connection accepted" << std::endl;
                    std::make_shared<Session>(std::move(socket))->Start();
                }

                DoAccept();
            });
    }

    tcp::acceptor acceptor_;
};

int main(int argc, char* argv[])
{
    try
    {
        if (argc != 2)
        {
            std::cerr << "Usage: server <port>\n";
            return 1;
        }

        boost::asio::io_context io_context;
        Server server(io_context, std::atoi(argv[1]));

        // 运行多个线程处理 I/O 事件
        std::vector<std::thread> threads;
        for (int i = 0; i < std::thread::hardware_concurrency(); ++i)
        {
            threads.emplace_back([&io_context]() { io_context.run(); });
        }

        for (auto& t : threads)
        {
            t.join();
        }
    }
    catch (std::exception& e)
    {
        std::cerr << "Exception: " << e.what() << "\n";
    }

    return 0;
}
```

---

### 客户端代码

客户端连接到服务器，并发送消息。

```cpp
#include <boost/asio.hpp>
#include <iostream>
#include <string>

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

class Client
{
public:
    Client(boost::asio::io_context& io_context, const std::string& host, const std::string& port)
        : socket_(io_context)
    {
        tcp::resolver resolver(io_context);
        boost::asio::connect(socket_, resolver.resolve(host, port));
    }

    void Send(const std::string& message)
    {
        boost::asio::write(socket_, boost::asio::buffer(message));
    }

    std::string Receive()
    {
        char reply[1024];
        size_t reply_length = boost::asio::read(socket_, boost::asio::buffer(reply, message_.size()));
        return std::string(reply, reply_length);
    }

private:
    tcp::socket socket_;
};

int main(int argc, char* argv[])
{
    try
    {
        if (argc != 4)
        {
            std::cerr << "Usage: client <host> <port> <message>\n";
            return 1;
        }

        boost::asio::io_context io_context;
        Client client(io_context, argv[1], argv[2]);

        std::string message = argv[3];
        client.Send(message);

        std::string reply = client.Receive();
        std::cout << "Reply: " << reply << std::endl;
    }
    catch (std::exception& e)
    {
        std::cerr << "Exception: " << e.what() << "\n";
    }

    return 0;
}
```

---

### 编译和运行

1. **安装 Boost**：
   - 确保已安装 Boost 库。可以从 [Boost 官网](https://www.boost.org/) 下载并安装。

2. **编译代码**：
   - 使用以下命令编译服务器和客户端代码：
     ```bash
     g++ -o server server.cpp -lboost_system -lpthread
     g++ -o client client.cpp -lboost_system
     ```

3. **运行服务器**：
   - 启动服务器，监听指定端口：
     ```bash
     ./server 12345
     ```

4. **运行客户端**：
   - 启动客户端，连接到服务器并发送消息：
     ```bash
     ./client 127.0.0.1 12345 "Hello, Server!"
     ```

---

### 代码说明

1. **服务器端**：
   - 使用 `tcp::acceptor` 监听客户端连接。
   - 每个客户端连接由一个 `Session` 对象处理，支持异步读写。
   - 使用多线程处理 I/O 事件，充分利用多核 CPU。

2. **客户端**：
   - 连接到服务器并发送消息。
   - 等待服务器的回复并打印。

3. **Boost.Asio 和 IOCP**：
   - Boost.Asio 在 Windows 平台上使用 IOCP 实现高效的异步 I/O。
   - 通过 `io_context.run()` 运行事件循环，处理异步操作。

---

### 注意事项

1. **线程安全**：
   - 在多线程环境中，确保共享资源的线程安全。

2. **错误处理**：
   - 在实际应用中，需要更完善的错误处理机制。

3. **性能优化**：
   - 对于高并发场景，可以调整线程池大小或使用更高效的数据结构。

通过以上代码，你可以实现一个基于 Boost.Asio 和 IOCP 的简单客户端-服务器程序。