C++ 网络编程实战：基于 TCP 协议的简易计算器实现

关键点说明：

• 多进程模型：通过 fork() 为每个客户端创建独立子进程，确保高并发下互不干扰。子进程关闭监听 socket，只处理当前连接。
• 回调机制：将具体的计算逻辑解耦，Start() 只负责传输，callback_ 负责业务。

服务端入口 (TcpServer.cc)

#include <iostream>
#include <string>
#include <functional>
#include "log.hpp"
#include "TcpServer.hpp"
#include "Protocol.hpp" // 修正拼写 Protocal -> Protocol

void Usage() {
    std::cout << "\n
" << "[Usage]: ./prot [port]" << "\n" << std::endl;
}

int main(int argc, char* argv[]) {
    if (argc != 2) {
        Usage();
        return -1;
    }

    lg(INFO, "Server start");
    ServerCal cal;

    // 解析端口号
    std::string port_1 = argv[1];
    uint16_t port = std::stoi(port_1);

    // 绑定回调函数
    TcpServer* tsur = new TcpServer(port, std::bind(&ServerCal::Calculator, &cal, std::placeholders::_1));
    tsur->Init();
    tsur->Start();
    return 0;
}

TCP 客户端实现

客户端主要负责发起连接、构造随机请求并解析响应。

#include <iostream>
#include <unistd.h>
#include <time.h>
#include <string>
#include "log.hpp"
#include "Socket.hpp"
#include "Protocol.hpp"

void Usage() {
    std::cout << "\n
" << "[Usage]: ./client [ip] [port]" << "\n" << std::endl;
}

int main(int argc, char* argv[]) {
    if (argc != 3) {
        Usage();
        return -1;
    }

    srand(time(nullptr));
    Sock sock;
    sock.Socket();

    std::string ip = argv[1];
    std::string port_1 = argv[2];
    std::cout << "port: " << port_1 << std::endl;
    uint16_t port = std::stoi(port_1);

    if (!sock.Connect(ip, port)) {
        lg(WARNING, "Connect failed");
        return -1;
    }
    lg(INFO, "connect successful");

    std::string op = "+-*/%";
    int cnt = 1;

    while (true) {
        cnt++;
        Requset req;
        req.x_ = rand() % 100 + 1;
        req.y_ = rand() % 100;
        req.op_ = op[rand() % op.size()];

        std::string con;
        bool r = req.Serialize(&con);
        if (!r) lg(WARNING, "Serialize failure");

        std::string out_stream = Encode(con);
        std::cout << "============ The " << cnt << " Request ============" << std::endl;
        std::cout << "x: " << req.x_ << ", op: " << req.op_ << ", y: " << req.y_ << std::endl;

        write(sock.GetFd(), out_stream.c_str(), out_stream.size());

        std::string in_stream;
        char inbuffer[1024];
        int n = read(sock.GetFd(), &inbuffer, sizeof(inbuffer));
        if (n > 0) {
            inbuffer[n] = 0;
            in_stream += inbuffer;
        }

        std::string bon;
        Response resp;
        Decode(in_stream, &bon);
        resp.Deserialize(bon);
        resp.Print();

        sleep(1);
        std::cout << "========================================" << std::endl;
    }
    return 0;
}

计算器业务逻辑 (ServerCal)

这里实现了核心的数学运算，包含除零检查等错误处理。

#pragma once
#include <iostream>
#include "log.hpp"
#include "Protocol.hpp"

enum err_symbol {
    div_zero = 1,
    mod_zero
};

class ServerCal {
public:
    ServerCal() {}

    // 执行具体计算
    Response Calculate(Requset &req) { // 修正拼写 Calculatate -> Calculate
        Response resp(0, 0);
        switch (req.op_) {
            case '+': resp.result_ = req.Getx() + req.Gety(); break;
            case '-': resp.result_ = req.Getx() - req.Gety(); break;
            case '*': resp.result_ = req.Getx() * req.Gety(); break;
            case '/':
                if (req.Gety() == 0) { resp.code_ = div_zero; break; }
                resp.result_ = req.Getx() / req.Gety();
                break;
            case '%':
                if (req.Gety() == 0) { resp.code_ = mod_zero; break; }
                resp.result_ = req.Getx() % req.Gety();
                break;
            default: break;
        }
        return resp;
    }

    // 处理完整数据包
    std::string Calculator(std::string &package) {
        std::string context;
        bool rDecode = Decode(package, &context);
        if (!rDecode) return "";

        Requset req;
        req.Deserialize(context);

        Response resp = Calculate(req);
        sleep(3); // 模拟计算延时

        std::string in;
        bool r = resp.Serialize(&in);
        if (!r) return "";

        context = "";
        context = Encode(in);
        return context;
    }

    ~ServerCal() {}
};

协议与序列化

为了保证数据传输的可靠性，我们自定义了简单的协议头（长度前缀），并实现了序列化和编码功能。

#pragma once
#include <iostream>
#include <string>
#include <cstring>
#include <jsoncpp/json/json.h>
#include "log.hpp"

const std::string space_sep = " ";
const std::string protocal_sep = "\n";

// 编码：添加长度前缀
std::string Encode(std::string &context) {
    std::string s = std::to_string(context.size());
    s += protocal_sep;
    s += context;
    s += protocal_sep;
    return s;
}

// 解码：提取有效载荷
bool Decode(std::string &package, std::string *context) {
    auto pos = package.find(protocal_sep);
    if (pos == std::string::npos) return false;

    std::string len_str = package.substr(0, pos);
    size_t len = std::stoi(len_str);
    int total_len = len + len_str.size() + 2;

    if (package.size() < total_len) return false;

    *context = package.substr(pos + 1, len);
    package.erase(0, total_len);
    return true;
}

// 请求类
class Requset {
public:
    Requset(int data1, char op, int data2) : x_(data1), op_(op), y_(data2) {}
    Requset() {}
    ~Requset() {}

    void Print() {
        std::cout << x_ << op_ << y_ << std::endl;
    }

    // 序列化：支持 JSON 或简单文本模式
    bool Serialize(std::string *out) {
#ifdef Myself
        std::string s = std::to_string(x_);
        s += space_sep;
        s += op_;
        s += space_sep;
        s += std::to_string(y_);
        *out = s;
        return true;
#else
        Json::Value root;
        root["x"] = x_;
        root["y"] = y_;
        root["op"] = op_;
        Json::FastWriter w;
        *out = w.write(root);
        return true;
#endif
    }

    bool Deserialize(const std::string &in) {
#ifdef Myself
        auto pos1 = in.find(space_sep);
        if (pos1 == std::string::npos) return false;
        auto pos2 = in.rfind(space_sep);
        std::string part_x = in.substr(0, pos1);
        std::string oper = in.substr(pos1 + 1, pos2);
        std::string part_y = in.substr(pos2 + 1);
        if (pos2 != pos1 + 2) return false;
        op_ = in[pos1 + 1];
        x_ = std::stoi(part_x);
        y_ = std::stoi(part_y);
        return true;
#else
        Json::Value root;
        Json::Reader r;
        r.parse(in, root);
        x_ = root["x"].asInt();
        y_ = root["y"].asInt();
        op_ = root["op"].asString()[0];
        return true;
#endif
    }

    int Getx() { return x_; }
    int Gety() { return y_; }
    char Getop() { return op_; }

private:
    int x_;
    char op_;
    int y_;
};

// 响应类
class Response {
public:
    Response(int ret, int code) : result_(ret), code_(code) {}
    Response() {}
    ~Response() {}

    bool Serialize(std::string *out) {
#ifdef Myself
        std::string s = std::to_string(result_);
        s += space_sep;
        s += std::to_string(code_);
        *out = s;
        return true;
#else
        Json::Value root;
        root["result"] = result_;
        root["code"] = code_;
        Json::FastWriter w;
        *out = w.write(root);
        return true;
#endif
    }

    bool Deserialize(const std::string &in) {
#ifdef Myself
        auto pos = in.find(space_sep);
        std::string res = in.substr(0, pos);
        std::string code = in.substr(pos + 1);
        if (pos != in.rfind(space_sep)) return false;
        result_ = std::stoi(res);
        code_ = std::stoi(code);
        return true;
#else
        Json::Value root;
        Json::Reader r;
        r.parse(in, root);
        result_ = root["result"].asInt();
        code_ = root["code"].asInt();
        return true;
#endif
    }

    void Print() {
        std::cout << "result_: " << result_ << " code_: " << code_ << std::endl;
    }

private:
    int result_;
    int code_;
};

网络组件封装 (Socket)

为了简化代码，我们将底层 socket API 封装成了 Sock 类，统一了错误处理和字节序转换。

#pragma once
#include <iostream>
#include <string>
#include <cstring>
#include <strings.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include "log.hpp"

int backlog = 10;

enum err {
    Socketerr = 1,
    Bindeterr,
    Listeneterr,
    Accepteterr
};

class Sock {
public:
    Sock() {}
    ~Sock() {}

    void Socket() {
        sockfd_ = socket(AF_INET, SOCK_STREAM, 0);
        if (sockfd_ < 0) {
            lg(FATAL, "Socket error: %d,%s", errno, strerror(errno));
            exit(Socketerr);
        }
    }

    void Bind(uint16_t port) {
        struct sockaddr_in peer;
        socklen_t len = sizeof(peer);
        bzero(&peer, len);
        peer.sin_port = htons(port);
        peer.sin_family = AF_INET;
        peer.sin_addr.s_addr = INADDR_ANY;

        if (bind(sockfd_, (struct sockaddr*)&(peer), len) < 0) {
            lg(FATAL, "Bind error: %d,%s", errno, strerror(errno));
            exit(Bindeterr);
        }
    }

    void Listen() {
        if (listen(sockfd_, backlog) < 0) {
            lg(FATAL, "Listen error: %d,%s", errno, strerror(errno));
            exit(Listeneterr);
        }
    }

    int Accept(std::string *clientip, uint16_t *clientport) {
        struct sockaddr_in peer;
        socklen_t len = sizeof(peer);
        bzero(&peer, len);

        int newfd = accept(sockfd_, (struct sockaddr*)&(peer), &len);
        if (newfd < 0) {
            lg(FATAL, "Accept error: %d,%s", errno, strerror(errno));
            exit(Accepteterr);
        }

        char ip[64];
        inet_ntop(AF_INET, &peer.sin_addr.s_addr, ip, sizeof(ip));
        *clientip = ip;
        *clientport = ntohs(peer.sin_port);
        return newfd;
    }

    bool Connect(const std::string &ip, const uint16_t &port) {
        struct sockaddr_in peer;
        socklen_t len = sizeof(peer);
        bzero(&peer, len);
        peer.sin_addr.s_addr = inet_addr(ip.c_str());
        peer.sin_port = htons(port);
        peer.sin_family = AF_INET;

        int n = connect(sockfd_, (struct sockaddr*)&(peer), len);
        if (n < 0) {
            lg(WARNING, "Connect error: %d,%s", errno, strerror(errno));
            return false;
        }
        return true;
    }

    void Close() {
        close(sockfd_);
    }

    int GetFd() {
        return sockfd_;
    }

private:
    int sockfd_;
};

运行效果

程序启动后，服务端监听指定端口，客户端持续发送随机计算请求，控制台会显示详细的交互过程。

源码地址

gitee.com/chian-ocean/linux/commit/b5a52c8da2fde96cbd683201e63353fa5dbc9b27