Používali jste standardní knihovny nebo jste vyvinuli…

Použil jsem jak standardní knihovny, tak vlastní řešení v závislosti na projektu a požadavcích.

Standardní knihovny:

Sockets API (BSD Sockets): Nízkoúrovňové API pro práci s TCP/IP. Používá se pro vytváření socketů, nastavování spojení, odesílání a přijímání dat.
Boost.Asio: Přenosná knihovna pro asynchronní vstup/výstup, často používaná pro síťové operace díky podpoře socketů, časovačů a dalších síťových primitiv.
libcurl: Klientská knihovna pro přenos dat přes různé protokoly (HTTP, HTTPS, FTP atd.).

Vlastní řešení:

Vyvíjel jsem vlastní knihovny a komponenty, když standardní řešení nesplňovala specifické požadavky projektu, například:

Vysoký výkon a nízká latence.
Nutnost implementace nestandardních protokolů.
Těsná integrace s dalšími komponenty systému.
Požadavky na odolnost vůči chybám a škálovatelnost přesahující běžné scénáře použití standardních knihoven.

Příklad použití vlastního řešení pro asynchronní TCP server:

// Zjednodušený příklad asynchronního TCP serveru s vlastním řešením
#include <iostream>
#include <vector>
#include <asio.hpp> // Často používané jako základ pro pooly vláken nebo asynchronní operace

class TcpServer {
public:
    TcpServer(asio::io_context& io_context, short port)
        : acceptor_(io_context, asio::ip::tcp::endpoint(asio::ip::tcp::v4(), port)) {
        start_accept();
    }

private:
    void start_accept() {
        // Čekání na nové spojení
        auto new_connection = std::make_shared<TcpConnection>(acceptor_.get_executor());
        acceptor_.async_accept(new_connection->socket(),
            [this, new_connection](const asio::error_code& error) {
            if (!error) {
                new_connection->start();
            }
            start_accept(); // Pokračuje v přijímání spojení
        });
    }

    asio::ip::tcp::acceptor acceptor_;
};

class TcpConnection : public std::enable_shared_from_this<TcpConnection> {
public:
    TcpConnection(asio::executor ex) : socket_(ex) {}

    asio::ip::tcp::socket& socket() { return socket_; }

    void start() {
        do_read();
    }

private:
    void do_read() {
        auto self(shared_from_this());
        socket_.async_read_some(asio::buffer(data_, max_length),
            [self](const asio::error_code& error, size_t bytes_transferred) {
            if (!error) {
                // Zpracování přijatých dat
                self->do_write(bytes_transferred);
            }
        });
    }

    void do_write(size_t length) {
        auto self(shared_from_this());
        asio::async_write(socket_, asio::buffer(data_, length),
            [self](const asio::error_code& error, size_t /*bytes_transferred*/) {
            if (!error) {
                self->do_read();
            }
        });
    }

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

// int main() {
//     try {
//         asio::io_context io_context;
//         TcpServer server(io_context, 8080);
//         io_context.run();
//     } catch (std::exception& e) {
//         std::cerr << "Výjimka: " << e.what() << "\n";
//     }
//     return 0;
// }

Porovnávací tabulka přístupů:

Přístup	Výhody	Nevýhody	Použití
Standardní knihovny	Rychlý vývoj, ověřené, dobrá dokumentace, podpora komunity.	Omezená flexibilita, možný overhead.	Většina běžných síťových úloh.
Vlastní řešení	Plná kontrola, vysoká flexibilita, optimalizace pro konkrétní úkoly.	Vysoké náklady na vývoj a údržbu, riziko chyb, nutnost testování.	Specifické požadavky na výkon, nestandardní protokoly, těsná integrace.

Obecně závisela volba na konkrétním projektu, jeho cílech a omezeních. Snažil jsem se najít optimální rovnováhu mezi použitím hotových řešení a vývojem vlastních, kde to bylo odůvodněné.

Používali jste standardní knihovny nebo jste vyvinuli vlastní řešení pro práci se sítí?