WebSocket em C++: aplicações em tempo real de nível avançado

Introdução: Por que WebSocket em C++ é a escolha dos profissionais para sistemas em tempo real

No mundo moderno das comunicações em tempo real — desde terminais de bolsa até jogos multijogador — a latência de milissegundos decide tudo. WebSocket em C++ permite alcançar desempenho inacessível para linguagens interpretadas. Neste artigo, abordaremos técnicas avançadas de criação de aplicações em tempo real em C++ usando a biblioteca Boost.Beast, que oferece controle de baixo nível sobre o protocolo e sobrecarga mínima.

Não abordaremos o básico — presume-se que você esteja familiarizado com programação de redes em C++ e fundamentos do WebSocket. Em vez disso, focaremos em arquitetura, escalabilidade, tratamento de erros e otimização de desempenho.

Arquitetura de um servidor WebSocket assíncrono em C++ com Boost.Beast

A principal vantagem do C++ é a capacidade de construir sistemas totalmente assíncronos sem a sobrecarga de threads. O Boost.Beast é construído sobre o Boost.Asio, oferecendo um poderoso conjunto de ferramentas para trabalhar com sockets de rede.

Estrutura básica do servidor

O servidor deve ser capaz de lidar com milhares de conexões simultâneas. Para isso, utiliza-se um event loop (io_context) e operações assíncronas. Vejamos uma implementação mínima, porém avançada:

#include <boost/beast/core.hpp>\n#include <boost/beast/websocket.hpp>\n#include <boost/asio.hpp>\n#include <memory>\n#include <string>\n#include <unordered_set>\n\nnamespace beast = boost::beast;\nnamespace websocket = beast::websocket;\nnamespace net = boost::asio;\nusing tcp = net::ip::tcp;\n\nclass WebSocketSession : public std::enable_shared_from_this<WebSocketSession> {\n    websocket::stream<beast::tcp_stream> ws_;\n    beast::flat_buffer buffer_;\n\npublic:\n    explicit WebSocketSession(tcp::socket&& socket)\n        : ws_(std::move(socket)) {}\n\n    void run() {\n        // Handshake assíncrono\n        ws_.async_accept(\n            beast::bind_front_handler(\n                &WebSocketSession::on_accept,\n                shared_from_this()));\n    }\n\nprivate:\n    void on_accept(beast::error_code ec) {\n        if (ec) return;\n        do_read();\n    }\n\n    void do_read() {\n        ws_.async_read(buffer_,\n            beast::bind_front_handler(\n                &WebSocketSession::on_read,\n                shared_from_this()));\n    }\n\n    void on_read(beast::error_code ec, std::size_t bytes_transferred) {\n        if (ec == websocket::error::closed) return;\n        if (ec) return;\n\n        // Processamento da mensagem\n        std::string msg = beast::buffers_to_string(buffer_.data());\n        buffer_.consume(buffer_.size());\n\n        // Resposta eco (em uma aplicação real - lógica de negócio)\n        ws_.text(ws_.got_text());\n        ws_.async_write(net::buffer(msg),\n            beast::bind_front_handler(\n                &WebSocketSession::on_write,\n                shared_from_this()));\n    }\n\n    void on_write(beast::error_code ec, std::size_t bytes_transferred) {\n        if (ec) return;\n        do_read();\n    }\n};

Gerenciamento de sessões e transmissão broadcast

Para um chat em tempo real ou monitoramento, é necessário enviar mensagens a todos os clientes conectados. Usamos um contêiner thread-safe:

class WebSocketServer {\n    net::io_context& ioc_;\n    tcp::acceptor acceptor_;\n    std::unordered_set<std::shared_ptr<WebSocketSession>> sessions_;\n    std::mutex sessions_mutex_;\n\npublic:\n    WebSocketServer(net::io_context& ioc, short port)\n        : ioc_(ioc)\n        , acceptor_(ioc, tcp::endpoint(tcp::v4(), port)) {\n        do_accept();\n    }\n\n    void broadcast(const std::string& message) {\n        std::lock_guard<std::mutex> lock(sessions_mutex_);\n        for (auto& session : sessions_) {\n            session->send(message);\n        }\n