Linux Socket UDP 编程实战：通信、翻译与聊天室 | 极客日志

C++

Linux Socket UDP 编程实战：通信、翻译与聊天室

Linux Socket UDP 编程实战，涵盖基础接口、简单通信、字典翻译及多客户端聊天室实现。通过 C++ 封装 UdpServer 类，结合回调函数解耦业务逻辑，演示了 bind 绑定、sendto/recvfrom 使用及 INADDR_ANY 配置。聊天室部分引入线程池与路由表管理在线用户，解决消息混杂问题，并支持跨平台（Linux/Windows）通信。

星河入梦发布于 2026/2/200 浏览

Linux Socket UDP 编程实战：通信、翻译与聊天室

Linux Socket UDP 编程实战

在网络基础学习中，我们已掌握网络体系结构与传输流程。本篇聚焦 Socket 编程中的 UDP 套接字，通过具体实例演示客户端与服务器的通信机制。我们将实现字典翻译和简单聊天室两个基于 UDP 的具体应用。

1. Socket 通信接口

在使用 UDP 进行通信前，先了解核心接口。

创建套接字

#include <sys/types.h>
#include <sys/socket.h>
int socket(int domain, int type, int protocol);

domain: 协议族，如 AF_INET (IPv4)。
type: 套接字类型，UDP 对应 SOCK_DGRAM。
protocol: 通常填 0，系统自动选择。成功返回文件描述符，失败返回 -1。

绑定端口

#include <sys/types.h>
#include <sys/socket.h>
int bind(int sockfd, const struct sockaddr *addr, socklen_t addrlen);

sockfd: 套接字描述符。
addr: 存储 IP 和端口的结构体指针。
addrlen: 结构体大小。绑定成功后返回 0，否则 -1。

对于 UDP 网络通信，需传入 sockaddr_in 结构体并强制转换为 sockaddr。

数据收发

// 接收数据
ssize_t recvfrom(int sockfd, void *buf,  len,  flags,
                  sockaddr *src_addr,  *addrlen);


;

#pragma once
#include <iostream>
#include <string>
#include <sys/types.h>
#include <sys/socket.h>
#include <strings.h>
#include "log.hpp"

const int defaultfd = -1;
class UdpServer {
public:
    // 构造函数
    UdpServer(u_int16_t port, std::string &ip) : _sockfd(defaultfd), _port(port), _isrunning(false), _ip(ip) {}
    void Init();
    void Start();
private:
    int _sockfd;
    uint16_t _port;
    std::string _ip;
    bool _isrunning;
};

void UdpServer::Init() {
    _sockfd = socket(AF_INET, SOCK_DGRAM, 0);
    if (_sockfd < 0) {
        LOG(LogLevel::FATAL) << "socket error!";
        exit(1);
    }
    LOG(LogLevel::INFO) << "socket success, sockfd:" << _sockfd;

    struct sockaddr_in local;
    bzero(&local, sizeof(local));
    local.sin_family = AF_INET;
    local.sin_port = htons(_port);
    local.sin_addr.s_addr = inet_addr(_ip.c_str());

    int n = bind(_sockfd, (struct sockaddr *)&local, sizeof(local));
    if (n < 0) {
        LOG(LogLevel::FATAL) << "bind error";
        exit(2);
    }
    LOG(LogLevel::INFO) << "bind success, sockfd:" << _sockfd;
}

void UdpServer::Start() {
    _isrunning = true;
    while (_isrunning) {
        char buffer[1024];
        struct sockaddr_in peer;
        socklen_t len = sizeof(peer);

        ssize_t s = recvfrom(_sockfd, buffer, sizeof(buffer) - 1, 0,
                             (struct sockaddr *)&peer, &len);
        if (s > 0) {
            buffer[s] = 0;
            // 发送回客户端
            sendto(_sockfd, buffer, sizeof(buffer) - 1, 0,
                   (struct sockaddr *)&peer, len);
        }
    }
}

#include <iostream>
#include <memory>
#include "UdpServer.hpp"

int main(int argc, char* argv[]) {
    if (argc != 3) {
        std::cerr << "Usage: " << argv[0] << " ip port" << std::endl;
        return 1;
    }
    uint16_t port = std::stoi(argv[2]);
    std::string ip = argv[1];
    std::unique_ptr<UdpServer> usvr = std::make_unique<UdpServer>(port, ip);
    usvr->Init();
    usvr->Start();
    return 0;
}

#include <iostream>
#include <string>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <cstring>

int main(int argc, char *argv[]) {
    if (argc != 3) {
        std::cerr << "Usage: " << argv[0] << " server_ip server_port" << std::endl;
        return 1;
    }
    std::string server_ip = argv[1];
    uint16_t server_port = std::stoi(argv[2]);

    int sockfd = socket(AF_INET, SOCK_DGRAM, 0);
    if (sockfd < 0) {
        std::cerr << "socket error" << std::endl;
        return 2;
    }

    struct sockaddr_in server;
    memset(&server, 0, sizeof(server));
    server.sin_family = AF_INET;
    server.sin_port = htons(server_port);
    server.sin_addr.s_addr = inet_addr(server_ip.c_str());

    while (1) {
        std::string input;
        std::cout << "Please input:";
        std::getline(std::cin, input);

        sendto(sockfd, input.c_str(), input.size(), 0,
               (struct sockaddr *)&server, sizeof(server));

        char buffer[1024];
        struct sockaddr_in peer;
        socklen_t len = sizeof(peer);
        int m = recvfrom(sockfd, buffer, sizeof(buffer) - 1, 0,
                         (struct sockaddr *)&peer, &len);
        if (m > 0) {
            buffer[m] = 0;
            std::cout << buffer << std::endl;
        }
    }
    return 0;
}

local.sin_addr.s_addr = INADDR_ANY; // 监听所有网卡

using func_t = std::function<std::string(const std::string &)>;
class UdpServer {
    // ... 成员变量
    func_t _func;
    // ...
    void Start() {
        // ...
        if (s > 0) {
            buffer[s] = 0;
            std::string result = _func(buffer); // 调用回调
            sendto(..., result.c_str(), ...);
        }
    }
};

#pragma once
#include <iostream>
#include <string>
#include <arpa/inet.h>
#include <sys/types.h>
#include <netinet/in.h>

class InetAddr {
public:
    InetAddr(struct sockaddr_in &addr) : _addr(addr) {
        _port = ntohs(_addr.sin_port);
        char buffer[64];
        inet_ntop(AF_INET, &_addr.sin_addr, buffer, sizeof(buffer));
        _ip = buffer;
    }
    uint16_t Port() { return _port; }
    std::string IP() { return _ip; }
private:
    struct sockaddr_in _addr;
    std::string _ip;
    uint16_t _port;
};

bool LoadDict() {
    std::ifstream in(_dict_path);
    if (!in.is_open()) return false;
    std::string line;
    while (std::getline(in, line)) {
        auto pos = line.find(":");
        if (pos == std::string::npos) continue;
        std::string english = line.substr(0, pos);
        std::string chinese = line.substr(pos + 1);
        if (!english.empty() && !chinese.empty()) {
            _dict.insert({english, chinese});
        }
    }
    return true;
}

Dict dict;
dict.LoadDict();
auto handler = [&dict](const std::string& msg, InetAddr peer) -> std::string {
    return dict.Translate(msg, peer);
};
std::unique_ptr<UdpServer> usvr = std::make_unique<UdpServer>(port, handler);

class Route {
    std::vector<InetAddr> _online_user;
    Mutex _mutex;
public:
    void MessageRoute(int sockfd, const std::string &Message, InetAddr &peer) {
        LockGuard lock(_mutex);
        if (!_IsExit(peer)) AddUser(peer);
        
        std::string send_msg = peer.StringAddr() + "#" + Message;
        for (auto &x : _online_user) {
            sendto(sockfd, send_msg.c_str(), send_msg.size(), 0,
                   (const struct sockaddr *)&x.GetAddr(), sizeof(x.GetAddr()));
        }
        if (Message == "QUIT") EraseUser(peer);
    }
};

ThreadPool<func_t2>* tp = ThreadPool<func_t2>::GetInstance();
auto task = std::bind(&Route::MessageRoute, &r, sockfd, message, peer);
tp->Enqueue(task);

// 收消息线程
void Receive() {
    while (1) {
        char buffer[1024];
        // ... recvfrom ...
        if (m > 0) {
            buffer[m] = 0;
            std::cerr << buffer << std::endl; // 输出到 stderr
        }
    }
}