计算机网络： Socket编程-EW帮帮网

计算机网络： Socket编程

引言

Socket编程是网络通信的核心技术之一，它允许不同主机之间的进程进行数据交换，是实现网络应用的基础。无论是简单的客户端-服务器通信，还是复杂的分布式系统，Socket都扮演着至关重要的角色。

本文将从基础的UDP和TCP协议出发，逐步介绍Socket编程的核心概念和实现方法。内容涵盖：

UDP编程：介绍无连接通信的实现，包括地址转换、本地环回、Echo服务器和字典服务器的开发。
TCP编程：深入讲解面向连接的通信，包括多进程、多线程和线程池版本的服务器实现，以及远程命令执行等实际应用。

通过代码示例和详细注释，读者可以快速掌握Socket编程的核心技术，并能够根据需求开发出高效、稳定的网络应用程序。无论你是初学者还是有一定经验的开发者，本文都能为你提供实用的指导和启发。

1.UDP网络编程

1.1 网络地址与端口转换函数

本文章只介绍基于IPV4的Socket网络编程，sockaddr_in中的成员struct in_addr sin_addr表示32位的IP地址。

但是我们通常用点分十进制的字符串表示IP地址，以下函数可以在字符串表示和in_addr表示之间转换。
- 字符串转in_addr的函数：
- in_addr转字符串的函数：
其中 inet_pton 和 inet_ntop 不仅可以转换 IPv4 的 in_addr，还可以转换 IPv6 的in6_addr，因此函数接口是 void *addrptr。
- 代码示例：
关于inet_ntoa
inet_ntoa 这个函数返回了一个 char*，显然是函数自己在内部申请了一块内存来保存 IP 的结果。那么是否需要调用者手动释放吗？

根据 man 手册，inet_ntoa 将返回结果存放在静态存储区，因此不需要手动释放。

但需要注意的是，由于 inet_ntoa 使用内部静态存储区，第二次调用的结果会覆盖上一次的结果。

思考：如果有多个线程调用 inet_ntoa，是否会出现异常情况？
- 在 APUE中明确指出，inet_ntoa 不是线程安全的函数；
- 但在 CentOS7 上测试时并未出现问题，可能是内部实现加了互斥锁；
- 在多线程环境下，推荐使用 inet_ntop，该函数要求调用者提供缓冲区存储结果，从而规避线程安全问题。
总结：以后进行网络地址与端口转换，就是用下面四个函数
1. inet_pton (地址字符串 -> 二进制)
  功能：将点分十进制的IP字符串转换为网络字节序的二进制形式
  参数：
  - af：地址族（AF_INET for IPv4, AF_INET6 for IPv6）
  - src：输入字符串（如 "192.168.1.1"）
  - dst：输出缓冲区（需提前分配）
  返回值：
  - 成功返回 1，失败返回 0 或 -1
  示例：
```
#include <arpa/inet.h>

struct in_addr addr;
inet_pton(AF_INET, "192.168.1.1", &addr);
```
2. inet_ntop (二进制 -> 地址字符串)
  功能：将网络字节序的二进制IP转换为可读字符串
  参数：
  - af：地址族
  - src：二进制地址（如 struct in_addr）
  - dst：输出字符串缓冲区
  - size：缓冲区大小（推荐用 INET_ADDRSTRLEN 宏）
  返回值：成功返回 dst 指针，失败返回 NULL
  
  示例：
```
char str[INET_ADDRSTRLEN];
inet_ntop(AF_INET, &addr, str, sizeof(str));
```
3. htons & ntohs (主机字节序 <-> 网络字节序)
  功能：
  - htons：主机字节序（小端/大端） -> 网络字节序（大端）
  - ntohs：网络字节序 -> 主机字节序
  参数：uint16_t 类型的端口号
  返回值：转换后的值
  
  示例：
```
uint16_t port_host = 8080;
uint16_t port_net = htons(port_host);  // 主机转网络
uint16_t port_back = ntohs(port_net); // 网络转主机
```
4. 注意事项
  1. 字节序问题：
    
    htons/ntohs 用于解决不同机器的字节序差异，网络传输必须用大端。
    
    即使主机字节序本身就是大端，调用这些函数也不会出错（无操作）。
  2. 缓冲区大小：
    
    inet_ntop 的缓冲区需足够大（IPv4用 INET_ADDRSTRLEN，IPv6用 INET6_ADDRSTRLEN）。
  3. 错误检查：
    
    inet_pton 和 inet_ntop 需检查返回值，无效输入会失败。

1.2 本地环回

本地环回（Local Loopback） 是指网络通信中，数据不经过物理网卡，而是直接在本地计算机内部回送（loop back）的一种机制。它主要用于测试本机的网络协议栈（如 TCP/IP）是否正常工作，或者用于本地进程间通信（IPC）。

环回地址
在 IPv4 中，标准的环回地址是 127.0.0.1（通常用 localhost 表示）。
在 IPv6 中，环回地址是 ::1。
- 当你访问 127.0.0.1 时，数据不会真正发送到网络上，而是在操作系统内部直接回送。
- 所有发送到 127.0.0.1 的数据都会被本机接收，适用于本地服务测试（如 Web 服务器、数据库等）。
环回接口
操作系统会虚拟一个 环回网卡（lo 或 lo0），专门用于处理环回流量：
- Linux/Unix：ifconfig lo 或 ip addr show lo
- Windows：ipconfig 可以看到 127.0.0.1 绑定在环回接口上
特点：
- 不需要物理网卡，纯软件实现。
- 即使没有网络连接，环回接口仍然可用。
常见用途
1. 测试网络服务
  - 例如运行一个本地 Web 服务器（如 http://127.0.0.1:8080），检查服务是否正常。
2. 进程间通信（IPC）
  - 两个本地进程可以通过 127.0.0.1 进行 Socket 通信，而无需经过外部网络。
3. 屏蔽外部访问
  - 某些服务（如数据库）可以只监听 127.0.0.1，防止外部机器连接，提高安全性。

示例（C++ Socket 绑定环回地址）

#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>

int main() {
    int sockfd = socket(AF_INET, SOCK_STREAM, 0);
    
    struct sockaddr_in local;
    local.sin_family = AF_INET;
    local.sin_port = htons(8080);  // 绑定 8080 端口
    local.sin_addr.s_addr = inet_addr("127.0.0.1");  // 绑定到环回地址
    
    // 绑定 Socket
    bind(sockfd, (struct sockaddr*)&local, sizeof(local));
    
    // ... 其他操作（listen, accept, ...）
    return 0;
}
//这样绑定的服务只能通过本机访问，外部机器无法连接。

1.3 `EchoServer`

简单的回显服务器和客户端代码

UdpServer.hpp

#pragma once  // 防止头文件被重复包含

// 包含必要的系统头文件
#include <iostream>    // 标准输入输出
#include <string>      // 字符串处理
#include <cerrno>      // 错误号定义
#include <cstring>     // 字符串操作函数
#include <unistd.h>    // POSIX系统调用
#include <strings.h>   // bzero等函数

//套接字编程必备4个头文件
#include <sys/types.h> // 系统数据类型
#include <sys/socket.h> // 套接字相关
#include <netinet/in.h> // 网络地址结构
#include <arpa/inet.h>  // IP地址转换

// 包含自定义头文件
#include "nocopy.hpp"  // 禁止拷贝的基类
#include "Log.hpp"     // 日志系统
#include "Comm.hpp"    // 通用通信定义
#include "InetAddr.hpp" // IP地址处理类

// 定义默认常量
const static uint16_t defaultport = 8888;  // 默认端口号
const static int defaultfd = -1;           // 默认无效文件描述符
const static int defaultsize = 1024;       // 默认缓冲区大小

// UDP服务器类，继承自nocopy表示禁止拷贝
class UdpServer : public nocopy
{
public:
// 构造函数，初始化端口号和socket文件描述符
UdpServer(uint16_t port = defaultport)
  : _port(port), _sockfd(defaultfd)
{
}

// 初始化UDP服务器
void Init()
{
  // 1. 创建socket文件描述符
  // AF_INET表示IPv4网络协议而非本地通信
  // SOCK_DGRAM表示UDP协议数据报通信
  // 0表示使用默认协议
  _sockfd = socket(AF_INET, SOCK_DGRAM, 0);
  if (_sockfd < 0)  // 创建失败处理
  {
      // 记录错误日志，包括错误号和错误信息
      lg.LogMessage(Fatal, "socket errr, %d : %s\n", errno, strerror(errno));
      exit(Socket_Err);  // 退出程序并返回错误码
  }
  // 记录socket创建成功的日志
  lg.LogMessage(Info, "socket success, sockfd: %d\n", _sockfd);

  // 2. 绑定socket到指定端口
  struct sockaddr_in local;  // 定义IPv4地址结构
  bzero(&local, sizeof(local));  // 清空结构体全部置0，等同于memset

  // 设置地址族为IPv4
  local.sin_family = AF_INET;
  // 设置端口号，htons将主机字节序转换为网络字节序
  local.sin_port = htons(_port);
  // 设置IP地址为INADDR_ANY(0.0.0.0)，表示监听所有网络接口
  local.sin_addr.s_addr = INADDR_ANY;
  //local.sin_addr.s_addr = inet_addr(_ip.c_str()); // 1. 4字节 IP 2. 变成网络序列
   
  // 绑定socket到指定的地址和端口
  int n = ::bind(_sockfd, (struct sockaddr *)&local, sizeof(local));//::表示调用全局命名空间
  if (n != 0)  // 绑定失败处理
  {
      // 记录绑定错误日志
      lg.LogMessage(Fatal, "bind errr, %d : %s\n", errno, strerror(errno));
      exit(Bind_Err);  // 退出程序并返回错误码
  }
}

// 启动服务器主循环
void Start()
{
  // 定义接收缓冲区
  char buffer[defaultsize];

  // 服务器主循环，永不退出
  for (;;)
  {
      // 定义客户端地址结构
      struct sockaddr_in peer;
      // 获取客户端地址结构长度
      socklen_t len = sizeof(peer);

      // 接收UDP数据报
      ssize_t n = recvfrom(_sockfd, buffer, sizeof(buffer)-1, 0, 
                         (struct sockaddr *)&peer, &len);
      // 参数说明：
      // _sockfd: socket文件描述符
      // buffer: 接收缓冲区
      // sizeof(buffer)-1: 缓冲区大小(保留一个字节给字符串结束符)
      // 0: 默认标志
      // (struct sockaddr *)&peer: 客户端地址结构
      // &len: 地址结构长度

      // 如果接收到数据(n>0)
      if (n > 0)
      {
          // 将接收到的数据以字符串形式处理(添加结束符)
          buffer[n] = 0;

          // 创建客户端地址对象并打印调试信息
          InetAddr addr(peer);
          // 输出接收到的消息和客户端地址信息
          std::cout << "[" << addr.PrintDebug() << "]# " << buffer << std::endl;

          // 将接收到的消息原样返回给客户端(echo服务)
          sendto(_sockfd, buffer, strlen(buffer), 0, 
                (struct sockaddr *)&peer, len);
      }
  }
}

// 析构函数
~UdpServer()
{
  // 注意：这里应该关闭socket文件描述符
  // 可以添加: if(_sockfd != defaultfd) close(_sockfd);
}

private:
uint16_t _port;  // 服务器监听端口
int _sockfd;     // socket文件描述符
};

INADDR_ANY宏定义

在网络编程中，云服务器不允许直接 bind 公有 IP，也不推荐编写服务器时绑定明确的 IP 地址，推荐直接写成 INADDR_ANY。当一个进程需要绑定网络端口进行通信时，使用 INADDR_ANY 作为 IP 地址参数意味着该端口可以接受来自任何 IP 地址的连接请求（无论是本地主机还是远程主机）。例如，若服务器有多个网卡（每个网卡对应不同 IP 地址），使用 INADDR_ANY 可省去确定数据具体来自哪个网卡/IP 地址的步骤。
/* Address to accept any incoming messages. */
#define INADDR_ANY ((in_addr_t) 0x00000000)

UdpClient.hpp

#include <iostream>       // 标准输入输出流
#include <cerrno>         // 错误号定义
#include <cstring>        // 字符串操作函数
#include <string>         // C++字符串类
#include <unistd.h>       // POSIX操作系统API
#include <sys/types.h>    // 基本系统数据类型
#include <sys/socket.h>   // 套接字接口
#include <arpa/inet.h>    // 互联网操作函数
#include <netinet/in.h>   // 互联网地址族

// 使用方法提示函数
void Usage(const std::string &process)
{
    std::cout << "Usage: " << process << " server_ip server_port" 
              << std::endl;
}

// 主函数：./udp_client server_ip server_port
int main(int argc, char *argv[])
{
    // 1. 参数校验
    if (argc != 3)
    {
        Usage(argv[0]);  // 打印使用方法
        return 1;        // 参数错误返回1
    }

    // 2. 解析命令行参数
    std::string serverip = argv[1];       // 服务器IP地址
    uint16_t serverport = std::stoi(argv[2]);  // 服务器端口号

    // 3. 创建UDP套接字
    // AF_INET: IPv4地址族
    // SOCK_DGRAM: 数据报套接字(UDP)
    // 0: 默认协议
    int sock = socket(AF_INET, SOCK_DGRAM, 0);
    if (sock < 0)
    {
        std::cerr << "socket error: " << strerror(errno) << std::endl;
        return 2;  // 套接字创建失败返回2
    }
    std::cout << "create socket success: " << sock << std::endl;

    //client需要bind,但是不需要显式bind，client会在首次发送数据的时候会自动进行bind。
    //server 端的端口号，一定是众所周知，不可改变的；client 需要端口bind 随机端口号，因为client 会非常多，所以让本地OS自动随机bind端口号。
    
    // 4. 准备服务器地址信息
    struct sockaddr_in server;
    memset(&server, 0, sizeof(server));  // 清空结构体
    server.sin_family = AF_INET;         // IPv4地址族
    server.sin_port = htons(serverport); // 端口号(主机字节序转网络字节序)
    server.sin_addr.s_addr = inet_addr(serverip.c_str()); // IP地址转换

    // 5. 主循环：发送和接收数据
    while (true)
    {
        // 5.1 获取用户输入
        std::string inbuffer;
        std::cout << "Please Enter# ";
        std::getline(std::cin, inbuffer);

        // 5.2 发送数据到服务器
        ssize_t n = sendto(sock,                  // 套接字描述符
                          inbuffer.c_str(),        // 发送数据缓冲区
                          inbuffer.size(),        // 数据长度
                          0,                      // 标志位(通常为0)
                          (struct sockaddr*)&server, // 服务器地址
                          sizeof(server));        // 地址长度
        
        if(n > 0)  // 发送成功
        {
            // 5.3 准备接收服务器响应
            char buffer[1024];  // 接收缓冲区
            
            // 临时存储对端地址信息
            struct sockaddr_in temp;
            socklen_t len = sizeof(temp);
            
            // 接收服务器响应
            ssize_t m = recvfrom(sock,           // 套接字描述符
                                buffer,          // 接收缓冲区
                                sizeof(buffer)-1, // 缓冲区大小(留1字节给'\0')
                                0,              // 标志位(通常为0)
                                (struct sockaddr*)&temp, // 对端地址
                                &len);          // 地址长度
            
            if(m > 0)  // 接收成功
            {
                buffer[m] = 0;  // 手动添加字符串结束符
                std::cout << "server echo# " << buffer << std::endl;
            }
            else
            {
                break;  // 接收失败退出循环
            }
        }
        else
        {
            break;  // 发送失败退出循环
        }
    }

    // 6. 关闭套接字
    close(sock);
    return 0;
}

recvfrom参数说明：

recvfrom 是用于 无连接协议（如 UDP） 的 Socket 接收函数，它不仅能接收数据，还能获取发送方的地址信息（IP + Port）。

参数说明

sockfd 已创建的 UDP Socket 描述符（由 socket(AF_INET, SOCK_DGRAM, 0) 返回）

buf 存储接收数据的缓冲区

len 缓冲区大小（字节数）

flags 控制选项（如 MSG_WAITALL、MSG_DONTWAIT，通常设为 0）

src_addr 存放发送方地址的 struct sockaddr（可以是 sockaddr_in 或 sockaddr_in6）

addrlen 输入时指定 src_addr 的大小，返回时是实际地址长度

参数	说明
`sockfd`	已创建的 UDP Socket 描述符（由 `socket(AF_INET, SOCK_DGRAM, 0)` 返回）
`buf`	存储接收数据的缓冲区
`len`	缓冲区大小（字节数）
`flags`	控制选项（如 `MSG_WAITALL`、`MSG_DONTWAIT`，通常设为 `0`）
`src_addr`	存放发送方地址的 `struct sockaddr`（可以是 `sockaddr_in` 或 `sockaddr_in6`）
`addrlen`	输入时指定 `src_addr` 的大小，返回时是实际地址长度

Comm.hpp

#pragma once

// 定义一个枚举类型来表示各种错误代码
// 枚举(enum)是一种用户定义的类型，包含一组命名的整数常量
enum {
    // 用法错误，赋值为1
    // 枚举默认从0开始，这里显式指定从1开始
    Usage_Err = 1,  
    
    // 套接字创建错误，自动赋值为2 (前一个值+1)
    // 表示创建网络套接字(socket)时发生的错误
    Socket_Err,
    
    // 绑定错误，自动赋值为3
    // 表示将套接字绑定到特定地址和端口时发生的错误
    Bind_Err
    
    // 注意：枚举值后面可以加逗号，也可以不加
    // 这里选择不加逗号以保持简洁
};

nocopy.hpp

// 防止头文件被重复包含的预处理指令
// 这是C/C++中防止多次包含同一头文件的常用方式
#pragma once  

// 包含标准输入输出流库，虽然当前类未使用，但通常保留以备后续扩展
#include <iostream>  

// 定义一个名为nocopy的类，其功能是禁止对象的拷贝操作
class nocopy  
{
public:  
 // 默认构造函数（无参构造函数）
 // 使用空实现，因为该类仅用于禁止拷贝，不需要特殊构造逻辑
 nocopy() {}  

 // 删除拷贝构造函数
 // = delete 是C++11特性，表示显式禁止该函数的自动生成和调用
 // 任何尝试拷贝nocopy对象的操作都会引发编译错误
 nocopy(const nocopy &) = delete;  

 // 删除拷贝赋值运算符
 // 同样使用=delete禁止，任何尝试赋值的操作都会引发编译错误
 const nocopy& operator=(const nocopy &) = delete;  

 // 析构函数
 // 使用空实现，因为该类没有需要特殊清理的资源
 // 声明为虚函数是更安全的做法（如果考虑继承），但当前实现未使用
 ~nocopy() {}  
};

// 该类典型用法：
// class MyClass : private nocopy { ... };
// 这样MyClass将自动禁用拷贝构造和拷贝赋值功能

InetAddr.hpp

#pragma once  // 防止头文件被重复包含

#include <iostream>      // 标准输入输出流
#include <string>        // 字符串处理
#include <sys/types.h>   // 系统类型定义
#include <sys/socket.h>  // 套接字相关函数和结构体
#include <netinet/in.h>  // 互联网地址族定义
#include <arpa/inet.h>   // 互联网操作函数

// InetAddr类：封装网络地址信息（IP和端口）
class InetAddr 
{
public:
    // 构造函数：通过sockaddr_in结构体初始化
    // 参数：addr - 包含IP和端口信息的socket地址结构体
    InetAddr(struct sockaddr_in &addr) : _addr(addr)
    {
        // 将网络字节序的端口号转换为主机字节序
        _port = ntohs(_addr.sin_port);
        
        // 将网络字节序的IP地址转换为点分十进制字符串
        _ip = inet_ntoa(_addr.sin_addr);
    }

    // 获取IP地址
    // 返回值：IP地址字符串
    std::string Ip() { return _ip; }

    // 获取端口号
    // 返回值：端口号（16位无符号整数）
    uint16_t Port() { return _port; };

    // 生成调试信息字符串
    // 返回值：格式为"IP:端口"的字符串（如"127.0.0.1:8080"）
    std::string PrintDebug()
    {
        std::string info = _ip;      // 添加IP部分
        info += ":";                // 添加分隔符
        info += std::to_string(_port); // 添加端口部分
        return info;
    }

    // 析构函数
    ~InetAddr(){}

private:
    std::string _ip;      // 存储IP地址（点分十进制字符串）
    uint16_t _port;       // 存储端口号（主机字节序）
    struct sockaddr_in _addr;  // 存储原始socket地址结构体
};

Log.hpp

#pragma once  // 防止头文件被重复包含

// 包含必要的标准库头文件
#include <iostream>    // 标准输入输出流
#include <string>      // 字符串处理
#include <fstream>     // 文件流操作
#include <memory>      // 智能指针
#include <ctime>       // 时间处理
#include <sstream>     // 字符串流
#include <filesystem>  // 文件系统操作(C++17)
#include <unistd.h>    // POSIX操作系统API
#include "Lock.hpp"    // 自定义锁实现

namespace LogModule
{
    // 使用我们自己封装的锁模块，也可以替换为C++标准库的锁
    using namespace LockModule;

    /********************** 常量定义 **********************/
    const std::string defaultpath = "./log/";  // 默认日志文件存储路径
    const std::string defaultname = "log.txt"; // 默认日志文件名

    /********************** 日志等级枚举 **********************/
    // 定义日志级别，用于区分日志的重要程度
    enum class LogLevel
    {
        DEBUG,   // 调试信息，用于开发阶段调试程序
        INFO,    // 普通信息，记录程序运行状态
        WARNING, // 警告信息，表示可能出现问题但不影响程序运行
        ERROR,   // 错误信息，表示程序出现错误但可以继续运行
        FATAL    // 致命错误，表示程序无法继续运行
    };

    /********************** 工具函数 **********************/
    
    /**
     * @brief 将日志等级枚举转换为可读字符串
     * @param level 日志等级枚举值
     * @return 对应的字符串描述
     */
    std::string LogLevelToString(LogLevel level)
    {
        switch (level)
        {
        case LogLevel::DEBUG:   return "DEBUG";   // 返回调试级别字符串
        case LogLevel::INFO:    return "INFO";    // 返回信息级别字符串
        case LogLevel::WARNING: return "WARNING"; // 返回警告级别字符串
        case LogLevel::ERROR:   return "ERROR";   // 返回错误级别字符串
        case LogLevel::FATAL:   return "FATAL";   // 返回致命错误字符串
        default:                return "UNKNOWN"; // 未知级别处理
        }
    }

    /**
     * @brief 获取当前格式化的时间字符串
     * @return 格式为"YYYY-MM-DD HH:MM:SS"的时间字符串
     */
    std::string GetCurrTime()
    {
        time_t tm = time(nullptr);  // 获取当前时间戳
        struct tm curr;             // 定义tm结构体
        localtime_r(&tm, &curr);    // 转换为本地时间(线程安全版本)
        
        // 使用snprintf格式化时间字符串，保证缓冲区安全
        char timebuffer[64];
        snprintf(timebuffer, sizeof(timebuffer), "%4d-%02d-%02d %02d:%02d:%02d",
                curr.tm_year + 1900,  // 年份(需要加1900)
                curr.tm_mon,         // 月份(0-11)
                curr.tm_mday,        // 日(1-31)
                curr.tm_hour,        // 时(0-23)
                curr.tm_min,         // 分(0-59)
                curr.tm_sec);        // 秒(0-59)
        
        return timebuffer;
    }

    /********************** 策略模式接口 **********************/
    
    /**
     * @brief 日志策略抽象基类
     * 定义日志输出的通用接口，具体实现由派生类完成
     */
    class LogStrategy
    {
    public:
        // 虚析构函数，确保派生类对象能正确释放资源
        virtual ~LogStrategy() = default;
        
        /**
         * @brief 同步日志接口
         * @param message 需要输出的日志消息
         */
        virtual void SyncLog(const std::string &message) = 0;
    };

    /********************** 具体策略实现 **********************/
    
    /**
     * @brief 控制台日志策略
     * 将日志输出到标准错误流(std::cerr)
     */
    class ConsoleLogStrategy : public LogStrategy
    {
    public:
        /**
         * @brief 实现日志同步输出到控制台
         * @param message 需要输出的日志消息
         */
        void SyncLog(const std::string &message) override
        {
            // 使用锁保护控制台输出，防止多线程竞争
            LockGuard LockGuard(_mutex);
            std::cerr << message << std::endl;  // 输出到标准错误流
        }

        // 析构函数(调试时可取消注释查看对象生命周期)
        ~ConsoleLogStrategy()
        {
            // std::cout << "~ConsoleLogStrategy" << std::endl;
        }

    private:
        Mutex _mutex;  // 互斥锁，保证控制台输出的线程安全
    };

    /**
     * @brief 文件日志策略
     * 将日志输出到指定文件中
     */
    class FileLogStrategy : public LogStrategy
    {
    public:
        /**
         * @brief 构造函数，初始化日志文件路径
         * @param logpath 日志文件存储路径
         * @param logfilename 日志文件名
         */
        FileLogStrategy(const std::string logpath = defaultpath, 
                       std::string logfilename = defaultname)
            : _logpath(logpath), _logfilename(logfilename)
        {
            // 使用锁保护目录创建操作
            LockGuard lockguard(_mutex);
            
            // 检查目录是否已存在
            if (std::filesystem::exists(_logpath))
                return;
            
            try
            {
                // 递归创建目录结构
                std::filesystem::create_directories(_logpath);
            }
            catch (const std::filesystem::filesystem_error &e)
            {
                // 捕获并输出文件系统异常
                std::cerr << e.what() << '\n';
            }
        }

        /**
         * @brief 实现日志同步输出到文件
         * @param message 需要输出的日志消息
         */
        void SyncLog(const std::string &message) override
        {
            // 使用锁保护文件写入操作
            LockGuard lockguard(_mutex);
            
            // 拼接完整文件路径
            std::string log = _logpath + _logfilename;
            
            // 以追加模式打开文件
            std::ofstream out(log.c_str(), std::ios::app);
            if (!out.is_open())
                return;  // 文件打开失败直接返回
                
            out << message << "\n";  // 写入日志内容
            out.close();            // 关闭文件
        }

        // 析构函数(调试时可取消注释查看对象生命周期)
        ~FileLogStrategy()
        {
            // std::cout << "~FileLogStrategy" << std::endl;
        }

    public:
        std::string _logpath;     // 日志文件存储路径
        std::string _logfilename; // 日志文件名
        Mutex _mutex;             // 互斥锁，保证文件写入的线程安全
    };

    /********************** 日志器主类 **********************/
    
    /**
     * @brief 日志器主类
     * 提供统一的日志接口，内部使用策略模式实现不同输出方式
     */
    class Logger
    {
    public:
        /**
         * @brief 默认构造函数
         * 初始化时默认使用控制台输出策略
         */
        Logger()
        {
            UseConsoleStrategy();  // 默认使用控制台策略
        }

        // 默认析构函数
        ~Logger() = default;

        /**
         * @brief 切换到控制台输出策略
         */
        void UseConsoleStrategy()
        {
            _strategy = std::make_unique<ConsoleLogStrategy>();
        }

        /**
         * @brief 切换到文件输出策略
         */
        void UseFileStrategy()
        {
            _strategy = std::make_unique<FileLogStrategy>();
        }

        /********************** 日志消息内部类 **********************/
        
        /**
         * @brief 日志消息内部类
         * 采用RAII技术管理单条日志的生命周期
         */
        class LogMessage
        {
        private:
            LogLevel _type;        // 日志等级
            std::string _curr_time; // 日志时间戳
            pid_t _pid;           // 进程ID
            std::string _filename; // 源文件名
            int _line;            // 源代码行号
            Logger &_logger;      // 引用外部Logger对象
            std::string _loginfo;  // 完整的日志信息

        public:
            /**
             * @brief 构造函数，初始化日志头部信息
             * @param type 日志等级
             * @param filename 源文件名
             * @param line 源代码行号
             * @param logger 外部Logger引用
             */
            LogMessage(LogLevel type, std::string &filename, int line, Logger &logger)
                : _type(type),
                  _curr_time(GetCurrTime()),
                  _pid(getpid()),
                  _filename(filename),
                  _line(line),
                  _logger(logger)
            {
                // 使用字符串流格式化日志头部信息
                std::stringstream ssbuffer;
                ssbuffer << "[" << _curr_time << "] "    // 时间
                          << "[" << LogLevelToString(type) << "] "  // 等级
                          << "[" << _pid << "] "          // 进程ID
                          << "[" << _filename << "] "     // 文件名
                          << "[" << _line << "]"          // 行号
                          << " - ";                       // 分隔符
                _loginfo = ssbuffer.str();  // 保存头部信息
            }

            /**
             * @brief 重载<<运算符，支持链式日志输入
             * @tparam T 任意可输出类型
             * @param info 需要输出的信息
             * @return 当前LogMessage对象的引用
             */
            template <typename T>
            LogMessage &operator<<(const T &info)
            {
                std::stringstream ssbuffer;
                ssbuffer << info;            // 格式化用户数据
                _loginfo += ssbuffer.str();  // 追加到日志信息
                return *this;                // 返回自身支持链式调用
            }

            /**
             * @brief 析构函数，在对象销毁时输出完整日志
             */
            ~LogMessage()
            {
                // 如果策略存在，则使用策略输出日志
                if (_logger._strategy)
                {
                    _logger._strategy->SyncLog(_loginfo);
                }
            }
        };

        /**
         * @brief 重载函数调用运算符，创建LogMessage临时对象
         * @param type 日志等级
         * @param filename 源文件名
         * @param line 源代码行号
         * @return 构造的LogMessage临时对象
         */
        LogMessage operator()(LogLevel type, std::string filename, int line)
        {
            return LogMessage(type, filename, line, *this);
        }

    private:
        std::unique_ptr<LogStrategy> _strategy;  // 日志输出策略智能指针
    };

    /********************** 全局对象和宏定义 **********************/
    
    Logger logger;  // 全局日志器对象

    // 定义日志宏，自动填充文件名和行号
    // 使用示例: LOG(LogLevel::INFO) << "This is a message";
    #define LOG(type) logger(type, __FILE__, __LINE__)

    // 定义策略切换宏
    #define ENABLE_CONSOLE_LOG_STRATEGY() logger.UseConsoleStrategy()  // 切换到控制台输出
    #define ENABLE_FILE_LOG_STRATEGY() logger.UseFileStrategy()       // 切换到文件输出
}

1.4 `DictServer`

实现一个简单的英译汉的网络字典

dict.txt

apple: 苹果
banana: 香蕉
cat: 猫
dog: 狗
book: 书
pen: 笔
happy: 快乐的
sad: 悲伤的
run: 跑
jump: 跳
teacher: 老师
student: 学生
car: 汽车
bus: 公交车
love: 爱
hate: 恨
hello: 你好
goodbye: 再见
summer: 夏天
winter: 冬天

Dict.hpp

#pragma once  // 防止头文件被重复包含

#include <iostream>    // 标准输入输出流
#include <string>      // 字符串操作
#include <fstream>     // 文件流操作
#include <unordered_map> // 无序哈希表容器

const std::string sep = ": ";  // 定义分隔符，用于分割键值对

// 字典类，用于加载和查询键值对数据
class Dict 
{
private:
    // 加载字典文件到内存
    void LoadDict() 
    {
        // 以输入模式打开配置文件
        std::ifstream in(_confpath);
        
        // 检查文件是否成功打开
        if (!in.is_open()) 
        {
            // 文件打开失败，输出错误信息（后续可用日志系统替代）
            std::cerr << "open file error" << std::endl; 
            return;
        }

        std::string line;  // 用于存储读取的每一行内容
        
        // 逐行读取文件内容
        while (std::getline(in, line)) 
        {
            // 跳过空行
            if (line.empty()) continue;
            
            // 查找分隔符位置
            auto pos = line.find(sep);
            
            // 如果没有找到分隔符，跳过该行
            if (pos == std::string::npos) continue;
            
            // 提取键（分隔符前的部分）
            std::string key = line.substr(0, pos);
            // 提取值（分隔符后的部分）
            std::string value = line.substr(pos + sep.size());
            
            // 将键值对插入到字典中
            _dict.insert(std::make_pair(key, value));
        }
        
        in.close();  // 关闭文件
    }

public:
    // 构造函数，接受配置文件路径作为参数
    Dict(const std::string &confpath) : _confpath(confpath) 
    {
        LoadDict();  // 构造时自动加载字典
    }

    // 查询方法：根据键查找对应的值
    std::string Translate(const std::string &key) 
    {
        // 在字典中查找键
        auto iter = _dict.find(key);
        
        // 如果没找到，返回"Unknown"
        if (iter == _dict.end()) 
            return std::string("Unknown");
        else 
            return iter->second;  // 找到则返回对应的值
    }

    // 析构函数（空实现）
    ~Dict() 
    {}

private:
    std::string _confpath;  // 存储配置文件路径
    std::unordered_map<std::string, std::string> _dict;  // 存储键值对的哈希表
};

UdpServer.hpp

#pragma once  // 防止头文件重复包含

// 系统头文件
#include <iostream>
#include <string>
#include <cerrno>      // 错误号相关
#include <cstring>     // 字符串操作
#include <unistd.h>    // POSIX系统调用
#include <strings.h>   // bzero等函数
#include <sys/types.h>  // 系统数据类型
#include <sys/socket.h> // socket相关
#include <netinet/in.h> // 网络地址结构
#include <arpa/inet.h>  // 地址转换函数
#include <unordered_map> // 哈希表
#include <functional>   // 函数对象

// 自定义头文件
#include "nocopy.hpp"   // 禁止拷贝的基类
#include "Log.hpp"      // 日志系统
#include "Comm.hpp"     // 通用定义
#include "InetAddr.hpp" // 网络地址封装类

// 默认配置常量
const static uint16_t defaultport = 8888;  // 默认端口号
const static int defaultfd = -1;           // 默认无效文件描述符
const static int defaultsize = 1024;       // 默认缓冲区大小

// 定义函数类型别名：处理请求并生成响应
using func_t = std::function<void(const std::string &req, std::string *resp)>;

/**
 * @class UdpServer
 * @brief UDP服务器类，继承自不可拷贝的基类
 */
class UdpServer : public nocopy
{
public:
    /**
     * @brief 构造函数
     * @param func 业务处理函数
     * @param port 服务器监听端口，默认为8888
     */
    UdpServer(func_t func, uint16_t port = defaultport)
        : _func(func), _port(port), _sockfd(defaultfd)
    {
    }

    /**
     * @brief 初始化服务器
     * 1. 创建socket
     * 2. 绑定端口
     */
    void Init()
    {
        // 1. 创建socket文件描述符
        // AF_INET: IPv4协议
        // SOCK_DGRAM: UDP协议
        // 0: 自动选择协议
        _sockfd = socket(AF_INET, SOCK_DGRAM, 0);
        if (_sockfd < 0)
        {
            // 创建失败记录日志并退出
            lg.LogMessage(Fatal, "socket error, %d : %s\n", errno, strerror(errno));
            exit(Socket_Err);
        }
        lg.LogMessage(Info, "socket success, sockfd: %d\n", _sockfd);

        // 2. 绑定端口和地址
        struct sockaddr_in local;
        bzero(&local, sizeof(local));  // 清空结构体
        
        // 设置地址族、端口和IP地址
        local.sin_family = AF_INET;           // IPv4地址族
        local.sin_port = htons(_port);         // 端口号转为网络字节序
        local.sin_addr.s_addr = INADDR_ANY;    // 监听所有网络接口
        
        // 绑定socket到指定地址
        int n = ::bind(_sockfd, (struct sockaddr *)&local, sizeof(local));
        if (n != 0)
        {
            // 绑定失败记录日志并退出
            lg.LogMessage(Fatal, "bind error, %d : %s\n", errno, strerror(errno));
            exit(Bind_Err);
        }
    }

    /**
     * @brief 启动服务器主循环
     */
    void Start()
    {
        char buffer[defaultsize];  // 接收缓冲区
        
        // 服务器主循环
        for (;;)
        {
            // 准备接收客户端信息
            struct sockaddr_in peer;      // 客户端地址结构
            socklen_t len = sizeof(peer); // 地址结构长度
            
            // 接收数据
            ssize_t n = recvfrom(_sockfd, buffer, sizeof(buffer) - 1, 0,
                                (struct sockaddr *)&peer, &len);
            
            if (n > 0)  // 接收成功
            {
                buffer[n] = 0;  // 添加字符串结束符
                
                // 打印客户端信息和消息内容
                InetAddr addr(peer);  // 封装客户端地址
                std::cout << "[" << addr.PrintDebug() << "]# " << buffer << std::endl;
                
                // 处理业务逻辑
                std::string value;
                _func(buffer, &value);  // 调用回调函数处理请求
                
                // 发送响应
                sendto(_sockfd, value.c_str(), value.size(), 0,
                       (struct sockaddr *)&peer, len);
            }
        }
    }

    /**
     * @brief 析构函数
     */
    ~UdpServer()
    {
        // 可以在这里关闭socket，但现代操作系统会在进程退出时自动关闭
    }

private:
    uint16_t _port;     // 服务器监听端口
    int _sockfd;        // socket文件描述符
    func_t _func;       // 业务处理回调函数
};

Main.cc

// 引入必要的头文件
#include "UdpServer.hpp"  // UDP服务器实现
#include "Comm.hpp"       // 通信相关定义
#include "Dict.hpp"       // 字典类定义
#include <memory>         // 智能指针

// 使用说明函数
void Usage(std::string proc)
{
    // 打印程序使用说明
    // proc 参数是程序名
    std::cout << "Usage : \n\t" << proc << " local_port\n" << std::endl;
}

// 全局字典对象，从dict.txt文件初始化
Dict gdict("./dict.txt");

// 请求处理函数
void Execute(const std::string &req, std::string *resp)
{
    // req: 客户端请求的字符串
    // resp: 用于返回响应结果的字符串指针
    
    // 调用字典对象的翻译功能处理请求
    *resp = gdict.Translate(req);
}

// 主函数
// 程序启动方式示例: ./udp_server 8888
int main(int argc, char *argv[])
{
    // 检查参数数量是否正确
    // 预期参数: 程序名 + 端口号 (共2个参数)
    if(argc != 2)
    {
        // 参数不正确时打印使用说明
        Usage(argv[0]);
        return Usage_Err;  // 返回使用错误码(定义在Comm.hpp中)
    }
    
    // 将字符串形式的端口号转换为整数
    uint16_t port = std::stoi(argv[1]);
    
    // 创建UDP服务器对象
    // 使用智能指针管理服务器对象生命周期
    // 参数1: 请求处理函数Execute
    // 参数2: 监听端口号
    std::unique_ptr<UdpServer> usvr = std::make_unique<UdpServer>(Execute, port);
    
    // 初始化服务器
    usvr->Init();
    
    // 启动服务器(进入事件循环)
    usvr->Start();
    
    return 0;  // 程序正常退出
}

1.5 `DictServer`封装版

udp_socket.hpp

#pragma once  // 防止头文件被重复包含

// 包含必要的头文件
#include <stdio.h>      // 标准输入输出
#include <string.h>     // 字符串操作
#include <stdlib.h>     // 标准库函数
#include <cassert>      // 断言
#include <string>       // C++字符串类
#include <unistd.h>     // POSIX系统调用
#include <sys/socket.h> // 套接字相关
#include <netinet/in.h> // 网络地址结构
#include <arpa/inet.h>  // 地址转换函数

// 类型别名定义，简化代码
typedef struct sockaddr sockaddr;      // 通用套接字地址结构
typedef struct sockaddr_in sockaddr_in; // IPv4套接字地址结构

// UDP套接字封装类
class UdpSocket {
public:
    // 构造函数，初始化fd_为无效值
    UdpSocket() : fd_(-1) {
    }

    // 创建UDP套接字
    bool Socket() {
        // 创建IPv4的UDP套接字
        fd_ = socket(AF_INET, SOCK_DGRAM, 0);
        if (fd_ < 0) {
            perror("socket");  // 打印错误信息
            return false;
        }
        return true;
    }

    // 关闭套接字
    bool Close() {
        close(fd_);
        fd_ = -1;  // 重置为无效值
        return true;
    }

    // 绑定套接字到指定IP和端口
    bool Bind(const std::string& ip, uint16_t port) {
        sockaddr_in addr;
        addr.sin_family = AF_INET;  // IPv4地址族
        addr.sin_addr.s_addr = inet_addr(ip.c_str());  // 将字符串IP转换为网络字节序
        addr.sin_port = htons(port);  // 将主机字节序端口转换为网络字节序

        // 绑定套接字
        int ret = bind(fd_, (sockaddr*)&addr, sizeof(addr));
        if (ret < 0) {
            perror("bind");
            return false;
        }
        return true;
    }

    // 接收UDP数据报
    bool RecvFrom(std::string* buf, std::string* ip = NULL, uint16_t* port = NULL) {
        char tmp[1024 * 10] = {0};  // 10KB的接收缓冲区
        sockaddr_in peer;  // 存储对端地址
        socklen_t len = sizeof(peer);  // 地址结构长度

        // 接收数据
        ssize_t read_size = recvfrom(fd_, tmp, sizeof(tmp) - 1, 0,
                                    (sockaddr*)&peer, &len);
        if (read_size < 0) {
            perror("recvfrom");
            return false;
        }

        // 将接收到的数据存入输出参数
        buf->assign(tmp, read_size);

        // 如果调用者需要，返回对端IP和端口
        if (ip != NULL) {
            *ip = inet_ntoa(peer.sin_addr);  // 网络字节序IP转字符串
        }
        if (port != NULL) {
            *port = ntohs(peer.sin_port);  // 网络字节序端口转主机字节序
        }
        return true;
    }

    // 发送UDP数据报
    bool SendTo(const std::string& buf, const std::string& ip, uint16_t port) {
        sockaddr_in addr;
        addr.sin_family = AF_INET;  // IPv4地址族
        addr.sin_addr.s_addr = inet_addr(ip.c_str());  // 字符串IP转网络字节序
        addr.sin_port = htons(port);  // 主机字节序端口转网络字节序

        // 发送数据
        ssize_t write_size = sendto(fd_, buf.data(), buf.size(), 0,
                                  (sockaddr*)&addr, sizeof(addr));
        if (write_size < 0) {
            perror("sendto");
            return false;
        }
        return true;
    }

private:
    int fd_;  // 套接字文件描述符
};

udp_server.hpp

#pragma once  // 防止头文件被重复包含

#include "udp_socket.hpp"  // 包含UDP socket的实现

// 定义请求处理函数的类型
// C风格写法（已注释）：
// typedef void (*Handler)(const std::string& req, std::string* resp);
// C++11风格写法，兼容函数指针、仿函数和lambda表达式
#include <functional>
typedef std::function<void(const std::string&, std::string*)> Handler;

/**
 * UDP服务器类
 * 封装了UDP服务器的基本操作
 */
class UdpServer {
public:
    /**
     * 构造函数
     * 创建UDP socket，如果创建失败会触发断言
     */
    UdpServer() {
        assert(sock_.Socket());  // 断言确保socket创建成功
    }

    /**
     * 析构函数
     * 关闭socket连接
     */
    ~UdpServer() {
        sock_.Close();  // 关闭socket
    }

    /**
     * 启动UDP服务器
     * @param ip 服务器绑定的IP地址
     * @param port 服务器绑定的端口号
     * @param handler 请求处理函数
     * @return 启动是否成功
     */
    bool Start(const std::string& ip, uint16_t port, Handler handler) {
        // 1. 绑定IP和端口
        bool ret = sock_.Bind(ip, port);
        if (!ret) {
            return false;  // 绑定失败返回false
        }

        // 2. 进入事件循环
        for (;;) {
            // 3. 接收客户端请求
            std::string req;            // 存储请求数据
            std::string remote_ip;      // 存储客户端IP
            uint16_t remote_port = 0;   // 存储客户端端口
            
            // 从socket接收数据
            bool ret = sock_.RecvFrom(&req, &remote_ip, &remote_port);
            if (!ret) {
                continue;  // 接收失败则继续循环
            }

            std::string resp;  // 存储响应数据
            
            // 4. 调用处理函数处理请求并生成响应
            handler(req, &resp);

            // 5. 将响应发送回客户端
            sock_.SendTo(resp, remote_ip, remote_port);

            // 打印日志信息
            printf("[%s:%d] req: %s, resp: %s\n", 
                   remote_ip.c_str(), remote_port,
                   req.c_str(), resp.c_str());
        }

        // 理论上不会执行到这里
        sock_.Close();
        return true;
    }

private:
    UdpSocket sock_;  // UDP socket对象，封装了底层socket操作
};

dict_server.cc

// 引入必要的头文件
#include "udp_server.hpp"  // UDP服务器实现头文件
#include <unordered_map>    // C++标准库中的哈希表容器
#include <iostream>         // 标准输入输出流

// 全局字典，用于存储单词及其翻译
// key: 英文单词
// value: 对应的翻译
std::unordered_map<std::string, std::string> g_dict;

/**
 * @brief 翻译函数，根据请求查询字典并返回结果
 * @param req 客户端请求的单词
 * @param resp 用于存储翻译结果的字符串指针
 */
void Translate(const std::string& req, std::string* resp) {
    // 在字典中查找请求的单词
    auto it = g_dict.find(req);
    
    // 如果没找到，返回提示信息
    if (it == g_dict.end()) {
        *resp = "未查到!";
        return;
    }
    
    // 找到则返回对应的翻译
    *resp = it->second;
}

/**
 * @brief 主函数，程序入口
 * @param argc 命令行参数个数
 * @param argv 命令行参数数组
 * @return 程序执行状态码
 */
int main(int argc, char* argv[]) {
    // 检查命令行参数是否正确
    if (argc != 3) {
        printf("Usage ./dict_server [ip] [port]\n");
        return 1;  // 参数错误返回非零状态码
    }
    
    // 1. 初始化字典数据
    g_dict.insert(std::make_pair("hello", "你好"));
    g_dict.insert(std::make_pair("world", "世界"));
    g_dict.insert(std::make_pair("c++", "最好的编程语言"));
    g_dict.insert(std::make_pair("bit", "特别 NB"));
    
    // 2. 创建并启动UDP服务器
    UdpServer server;  // 创建UDP服务器实例
    
    // 启动服务器，参数依次为：
    // argv[1] - IP地址
    // atoi(argv[2]) - 端口号(转换为整数)
    // Translate - 请求处理回调函数
    server.Start(argv[1], atoi(argv[2]), Translate);
    
    return 0;  // 正常退出
}

udp_client.hpp

// 防止头文件被重复包含的预处理指令
#pragma once  

// 包含UDP套接字封装类的头文件
#include "udp_socket.hpp"  

// UDP客户端类定义
class UdpClient {
public:
    /**
     * 构造函数
     * @param ip 服务器IP地址，字符串类型
     * @param port 服务器端口号，16位无符号整数
     * 功能：初始化客户端并创建UDP套接字
     */
    UdpClient(const std::string& ip, uint16_t port) 
        : ip_(ip),       // 初始化服务器IP
          port_(port) {  // 初始化服务器端口
        // 断言检查套接字是否创建成功，失败则程序终止
        assert(sock_.Socket());
    }

    /**
     * 析构函数
     * 功能：关闭UDP套接字，释放资源
     */
    ~UdpClient() {
        sock_.Close();  // 调用套接字关闭方法
    }

    /**
     * 接收数据方法
     * @param buf 输出参数，用于存储接收到的数据
     * @return bool 接收成功返回true，失败返回false
     * 功能：从套接字接收数据（会阻塞直到收到数据）
     */
    bool RecvFrom(std::string* buf) {
        return sock_.RecvFrom(buf);  // 调用套接字的接收方法
    }

    /**
     * 发送数据方法
     * @param buf 要发送的数据内容
     * @return bool 发送成功返回true，失败返回false
     * 功能：向构造函数指定的服务器地址发送数据
     */
    bool SendTo(const std::string& buf) {
        // 调用套接字发送方法，目标地址已在构造函数中指定
        return sock_.SendTo(buf, ip_, port_);  
    }

private:
    UdpSocket sock_;      // UDP套接字对象，封装了底层socket API
    std::string ip_;      // 服务器IP地址（IPv4格式，如"192.168.1.1"）
    uint16_t port_;       // 服务器端口号（0-65535）
};

main.cc

// 引入必要的头文件
#include "udp_client.hpp"  // 自定义的UDP客户端类头文件
#include <iostream>        // 标准输入输出流
#include <cstdlib>         // 用于atoi函数（字符串转整数）

// 主函数
int main(int argc, char* argv[]) {
    // 参数检查：程序需要接收2个参数（IP地址和端口号）
    // argc是参数个数，argv[0]是程序名，argv[1]是IP，argv[2]是端口
    if (argc != 3) {
        // 打印使用说明
        printf("Usage ./dict_client [ip] [port]\n");
        return 1;  // 非正常退出
    }

    // 创建UDP客户端对象
    // argv[1]是服务器IP地址，atoi(argv[2])将端口字符串转换为整数
    UdpClient client(argv[1], atoi(argv[2]));

    // 主循环：持续接收用户输入并查询
    for (;;) {
        std::string word;  // 存储用户输入的单词
        
        // 提示用户输入
        std::cout << "请输入您要查的单词: ";
        std::cin >> word;  // 读取用户输入

        // 检查输入流状态（用户可能输入EOF，如Ctrl+D）
        if (!std::cin) {
            std::cout << "Good Bye" << std::endl;  // 告别信息
            break;  // 退出循环
        }

        // 发送查询请求到服务器
        client.SendTo(word);

        // 准备接收服务器响应
        std::string result;
        
        // 接收服务器返回的查询结果
        client.RecvFrom(&result);

        // 输出查询结果
        std::cout << word << " 意思是 " << result << std::endl;
    }

    return 0;  // 正常退出
}

1.6 简单聊天室

UdpServer.hpp

#pragma once

// 系统头文件
#include <iostream>
#include <string>
#include <cerrno>
#include <cstring>
#include <unistd.h>
#include <strings.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <functional>
#include <pthread.h>

// 自定义头文件
#include "nocopy.hpp"
#include "Log.hpp"
#include "Comm.hpp"
#include "InetAddr.hpp"
#include "ThreadPool.hpp"

// 默认配置常量
const static uint16_t defaultport = 8888;  // 默认端口号
const static int defaultfd = -1;          // 默认文件描述符(无效值)
const static int defaultsize = 1024;     // 默认缓冲区大小

// 类型别名定义
using task_t = std::function<void()>;    // 线程任务类型

/**
 * @class UdpServer
 * @brief UDP服务器类，实现基于UDP的网络通信服务
 * 
 * 继承自nocopy类，禁止拷贝构造和赋值操作
 * 使用线程池处理客户端消息，支持多客户端在线通信
 */
class UdpServer : public nocopy
{
public:
    /**
     * @brief 构造函数
     * @param port 服务器监听端口，默认为defaultport
     */
    UdpServer(uint16_t port = defaultport) 
        : _port(port), _sockfd(defaultfd)
    {
        // 初始化用户列表互斥锁
        pthread_mutex_init(&_user_mutex, nullptr);
    }

    /**
     * @brief 初始化服务器
     * 1. 创建socket
     * 2. 绑定端口
     * 3. 启动线程池
     */
    void Init()
    {
        // 1. 创建UDP socket
        _sockfd = socket(AF_INET, SOCK_DGRAM, 0);
        if (_sockfd < 0)
        {
            lg.LogMessage(Fatal, "socket error, %d : %s\n", errno, strerror(errno));
            exit(Socket_Err);
        }
        lg.LogMessage(Info, "socket success, sockfd: %d\n", _sockfd);

        // 2. 绑定服务器地址
        struct sockaddr_in local;
        bzero(&local, sizeof(local));  // 清空结构体
        local.sin_family = AF_INET;    // IPv4地址族
        local.sin_port = htons(_port); // 端口号(主机序转网络序)
        local.sin_addr.s_addr = INADDR_ANY; // 监听所有网卡

        // 绑定socket到指定地址
        int n = ::bind(_sockfd, (struct sockaddr *)&local, sizeof(local));
        if (n != 0)
        {
            lg.LogMessage(Fatal, "bind error, %d : %s\n", errno, strerror(errno));
            exit(Bind_Err);
        }

        // 3. 启动线程池
        ThreadPool<task_t>::GetInstance()->Start();
    }

    /**
     * @brief 添加在线用户
     * @param addr 要添加的用户地址信息
     * 
     * 线程安全操作，使用互斥锁保护在线用户列表
     */
    void AddOnlineUser(InetAddr addr)
    {
        LockGuard lockguard(&_user_mutex);  // 自动加锁解锁
        
        // 检查用户是否已存在
        for (auto &user : _online_user)
        {
            if (addr == user)
                return;
        }
        
        // 添加新用户并记录日志
        _online_user.push_back(addr);
        lg.LogMessage(Debug, "%s:%d is add to onlineuser list...\n", 
                     addr.Ip().c_str(), addr.Port());
    }

    /**
     * @brief 消息路由函数
     * @param sock 发送消息的socket
     * @param message 要发送的消息内容
     * 
     * 将消息广播给所有在线用户
     */
    void Route(int sock, const std::string &message)
    {
        LockGuard lockguard(&_user_mutex);  // 自动加锁解锁
        
        // 遍历所有在线用户发送消息
        for (auto &user : _online_user)
        {
            sendto(sock, message.c_str(), message.size(), 0,
                  (struct sockaddr *)&user.GetAddr(), sizeof(user.GetAddr()));
            
            lg.LogMessage(Debug, "server send message to %s:%d, message: %s\n", 
                         user.Ip().c_str(), user.Port(), message.c_str());
        }
    }

    /**
     * @brief 启动服务器主循环
     * 
     * 循环接收客户端消息，并将消息转发给所有在线用户
     */
    void Start()
    {
        char buffer[defaultsize];  // 接收缓冲区
        
        // 服务器主循环
        for (;;)
        {
            struct sockaddr_in peer;  // 客户端地址
            socklen_t len = sizeof(peer);  // 地址长度
            
            // 接收客户端消息
            ssize_t n = recvfrom(_sockfd, buffer, sizeof(buffer) - 1, 0, 
                                (struct sockaddr *)&peer, &len);
            
            if (n > 0)  // 接收到有效数据
            {
                // 1. 处理客户端地址信息
                InetAddr addr(peer);
                
                // 2. 添加用户到在线列表
                AddOnlineUser(addr);
                
                // 3. 处理接收到的消息(添加结束符)
                buffer[n] = 0;
                
                // 4. 构造转发消息格式: [IP:Port]# 消息内容
                std::string message = "[";
                message += addr.Ip();
                message += ":";
                message += std::to_string(addr.Port());
                message += "]# ";
                message += buffer;
                
                // 5. 创建转发任务并提交到线程池
                task_t task = std::bind(&UdpServer::Route, this, _sockfd, message);
                ThreadPool<task_t>::GetInstance()->Push(task);
            }
        }
    }

    /**
     * @brief 析构函数
     * 
     * 释放资源，销毁互斥锁
     */
    ~UdpServer()
    {
        pthread_mutex_destroy(&_user_mutex);
    }

private:
    uint16_t _port;                // 服务器监听端口
    int _sockfd;                   // 服务器socket文件描述符
    std::vector<InetAddr> _online_user;  // 在线用户列表
    pthread_mutex_t _user_mutex;   // 保护在线用户列表的互斥锁
};

引入线程池，这里就不重复贴代码了。

InetAddr.hpp

#pragma once  // 防止头文件重复包含

#include <iostream>      // 标准输入输出流
#include <string>        // 字符串处理
#include <sys/types.h>   // 系统数据类型定义
#include <sys/socket.h>  // 套接字相关函数和数据结构
#include <netinet/in.h>  // 互联网地址族定义
#include <arpa/inet.h>  // 互联网操作声明（如inet_ntoa等）

// 网络地址封装类
class InetAddr {
public:
    // 构造函数：通过sockaddr_in结构体初始化
    // 参数：addr - 包含IP和端口信息的sockaddr_in结构体
    InetAddr(struct sockaddr_in &addr) : _addr(addr) {
        // 将网络字节序的端口号转换为主机字节序
        _port = ntohs(_addr.sin_port);
        // 将网络字节序的IP地址转换为点分十进制字符串
        _ip = inet_ntoa(_addr.sin_addr);
    }

    // 获取IP地址字符串
    std::string Ip() {
        return _ip;
    }

    // 获取端口号
    uint16_t Port() {
        return _port;
    };

    // 生成调试信息字符串，格式如："127.0.0.1:4444"
    std::string PrintDebug() {
        std::string info = _ip;
        info += ":";
        info += std::to_string(_port);
        return info;
    }

    // 获取内部的sockaddr_in结构体引用
    const struct sockaddr_in& GetAddr() {
        return _addr;
    }

    // 重载==运算符，比较两个InetAddr对象是否相等
    bool operator==(const InetAddr& addr) {
        // 比较IP和端口是否相同
        return this->_ip == addr._ip && this->_port == addr._port;
    }

    // 析构函数
    ~InetAddr() {}

private:
    std::string _ip;      // 存储IP地址的字符串
    uint16_t _port;       // 存储端口号
    struct sockaddr_in _addr;  // 存储原始的网络地址结构
};

UdpClient.hpp

#include <iostream>      // 标准输入输出流
#include <cerrno>       // 错误号定义
#include <cstring>      // 字符串操作函数
#include <string>       // C++字符串类
#include <unistd.h>     // POSIX标准函数
#include <sys/types.h>  // 基本系统数据类型
#include <sys/socket.h> // 套接字接口
#include <arpa/inet.h>  // 网络地址转换
#include <netinet/in.h> // 互联网地址族
#include "Thread.hpp"   // 自定义线程头文件
#include "InetAddr.hpp" // 自定义网络地址头文件

// 使用方法提示函数
void Usage(const std::string &process) {
    std::cout << "Usage: " << process << " server_ip server_port" 
              << std::endl;
}

// 线程数据类，封装了套接字和服务器地址信息
class ThreadData {
public:
    // 构造函数，初始化套接字和服务器地址
    ThreadData(int sock, struct sockaddr_in &server) 
        : _sockfd(sock), _serveraddr(server) {
    }
    
    ~ThreadData() {
    }
    
public:
    int _sockfd;        // 套接字文件描述符
    InetAddr _serveraddr; // 服务器地址信息
};

// 接收线程的工作函数
void RecverRoutine(ThreadData &td) {
    char buffer[4096];  // 接收缓冲区
    
    while (true) {
        struct sockaddr_in temp;  // 临时存储发送方地址
        socklen_t len = sizeof(temp);
        
        // 从套接字接收数据
        ssize_t n = recvfrom(td._sockfd, buffer, sizeof(buffer) - 1, 0, 
                            (struct sockaddr *)&temp, &len);
        
        if (n > 0) {
            buffer[n] = 0;  // 确保字符串以null结尾
            std::cerr << buffer << std::endl;  // 打印接收到的数据
        } else {
            break;  // 接收出错则退出循环
        }
    }
}

// 发送线程的工作函数
void SenderRoutine(ThreadData &td) {
    while (true) {
        std::string inbuffer;  // 存储用户输入
        std::cout << "Please Enter# ";
        std::getline(std::cin, inbuffer);  // 获取用户输入
        
        auto server = td._serveraddr.GetAddr();  // 获取服务器地址
        
        // 向服务器发送数据
        ssize_t n = sendto(td._sockfd, inbuffer.c_str(), inbuffer.size(), 
                          0, (struct sockaddr *)&server, sizeof(server));
        
        if (n <= 0) {
            std::cout << "send error" << std::endl;  // 发送失败提示
        }
    }
}

// 主函数
// 使用方法: ./udp_client server_ip server_port
int main(int argc, char *argv[]) {
    // 检查参数数量
    if (argc != 3) {
        Usage(argv[0]);
        return 1;
    }
    
    std::string serverip = argv[1];       // 获取服务器IP
    uint16_t serverport = std::stoi(argv[2]);  // 获取服务器端口
    
    // 1. 创建UDP套接字
    // UDP是全双工的，可以同时读写，不会有多线程读写问题
    int sock = socket(AF_INET, SOCK_DGRAM, 0);
    if (sock < 0) {
        std::cerr << "socket error: " << strerror(errno) << std::endl;
        return 2;
    }
    std::cout << "create socket success: " << sock << std::endl;
    
    // 2. 客户端不需要显式bind，首次发送数据时会自动bind随机端口
    // 服务器端口是固定的，客户端端口由OS自动分配
    
    // 2.1 填充服务器地址信息
    struct sockaddr_in server;
    memset(&server, 0, sizeof(server));
    server.sin_family = AF_INET;                  // IPv4地址族
    server.sin_port = htons(serverport);          // 端口号(网络字节序)
    server.sin_addr.s_addr = inet_addr(serverip.c_str());  // IP地址
    
    // 创建线程数据对象
    ThreadData td(sock, server);
    
    // 创建接收和发送线程
    Thread<ThreadData> recver("recver", RecverRoutine, td);
    Thread<ThreadData> sender("sender", SenderRoutine, td);
    
    // 启动线程
    recver.Start();
    sender.Start();
    
    // 等待线程结束
    recver.Join();
    sender.Join();
    
    close(sock);  // 关闭套接字
    return 0;
}

在这里插入图片描述

2.TCP网络编程

2.1 TCP Socket API详解

socket
- socket() 打开一个网络通讯端口，如果成功则像 open() 一样返回一个文件描述符；
- 应用程序可以像读写文件一样用 read/write 在网络上收发数据；
- 如果 socket() 调用出错则返回 -1；
- 对于 IPv4，family 参数指定为 AF_INET；
- 对于 TCP 协议，type 参数指定为 SOCK_STREAM，表示面向流的传输协议；protocol 参数可指定为 0。
bind
- 服务器程序所监听的网络地址和端口号通常是固定不变的，客户端程序得知服务器程序的地址和端口号后就可以向服务器发起连接；服务器需要调用 bind 绑定一个固定的网络地址和端口号；
- bind() 成功返回 0，失败返回 -1。
- bind() 的作用是将参数 sockfd 和 myaddr 绑定在一起，使 sockfd 这个用于网络通讯的文件描述符监听 myaddr 所描述的地址和端口号；
- 前面讲过，struct sockaddr * 是一个通用指针类型，myaddr 参数实际上可以接受多种协议的 sockaddr 结构体，而它们的长度各不相同，所以需要第三个参数 addrlen 指定结构体的长度。
我们的程序对myaddr参数是这样初始化的
1. 将整个结构体清零；
2. 设置地址类型为 AF_INET；
3. 网络地址为 INADDR_ANY（该宏表示本地的任意 IP 地址，因服务器可能有多个网卡，每个网卡可能绑定多个 IP 地址，此设置可在所有 IP 地址上监听，直到与客户端建立连接时才确定具体使用的 IP 地址）；
4. 端口号为 SERV_PORT（定义为 9999）。
listen
- listen() 声明 sockfd 处于监听状态（只要tcp服务器处于listen状态，那么他就可以被连接了），并且最多允许有 backlog 个客户端处于连接等待状态，如果接收到更多的连接请求就忽略，这里设置不会太大（一般是 5）。
- listen() 成功返回 0，失败返回 -1。
accept
- 三次握手完成后，服务器调用 accept() 接受连接；
- 如果服务器调用 accept() 时还没有客户端的连接请求，就阻塞等待直到有客户端连接上来；
- addr 是一个传出参数，accept() 返回时传出客户端的地址和端口号；
- 如果给 addr 参数传 NULL，表示不关心客户端的地址；
- addrlen 参数是一个传入传出参数（value-result argument），传入的是调用者提供的缓冲区 addr 的长度以避免缓冲区溢出问题，传出的是客户端地址结构体的实际长度（有可能没有占满调用者提供的缓冲区）。
我们的服务器程序结构是这样的

listenfd只负责获取链接，accept返回值，就是给我们提供的服务（IO）。
connect
- 客户端需要调用 connect() 连接服务器；
- connect 和 bind 的参数形式一致，区别在于 bind 的参数是自己的地址，而 connect 的参数是对方的地址；
- connect() 成功返回 0，出错返回 -1。

2.2 `Echo Server`

TcpServer.hpp

#pragma once  // 防止头文件被重复包含

#include <iostream>
#include <string>
#include <cerrno>      // 错误码相关
#include <cstring>     // 字符串操作
#include <cstdlib>     // 退出函数
#include <sys/types.h> // 系统类型定义
#include <sys/socket.h> // socket相关
#include <netinet/in.h> // 网络地址结构
#include <arpa/inet.h>  // 地址转换
#include "Log.hpp"      // 日志模块
#include "nocopy.hpp"   // 禁止拷贝基类
#include "Comm.hpp"     // 通用定义

const static int default_backlog = 6; // 监听队列的最大长度

// TCP服务器类，继承自nocopy（禁止拷贝）
class TcpServer : public nocopy
{
public:
    // 构造函数，初始化端口号和运行状态
    TcpServer(uint16_t port) : _port(port), _isrunning(false)
    {
    }

    // 初始化服务器
    void Init()
    {
        // 1. 创建socket文件描述符
        // AF_INET: IPv4, SOCK_STREAM: 流式套接字(TCP), 0: 默认协议
        _listensock = socket(AF_INET, SOCK_STREAM, 0);
        if (_listensock < 0)  // 创建失败
        {
            lg.LogMessage(Fatal, "create socket error, errno code: %d, error string: %s\n", 
                         errno, strerror(errno));
            exit(Fatal);  // 致命错误退出
        }
        
        // 设置socket选项，允许地址和端口重用
        int opt = 1;
        setsockopt(_listensock, SOL_SOCKET, SO_REUSEADDR | SO_REUSEPORT, &opt, sizeof(opt));
        lg.LogMessage(Debug, "create socket success, sockfd: %d\n", _listensock);

        // 2. 绑定本地网络信息
        struct sockaddr_in local;
        memset(&local, 0, sizeof(local));  // 清空结构体
        local.sin_family = AF_INET;        // IPv4
        local.sin_port = htons(_port);      // 端口号（主机序转网络序）
        local.sin_addr.s_addr = htonl(INADDR_ANY);  // 监听所有网卡

        // 绑定socket
        if (bind(_listensock, CONV(&local), sizeof(local))  // CONV可能是类型转换宏
        {
            lg.LogMessage(Fatal, "bind socket error, errno code: %d, error string: %s\n", 
                         errno, strerror(errno));
            exit(Bind_Err);  // 绑定错误退出
        }
        lg.LogMessage(Debug, "bind socket success, sockfd: %d\n", _listensock);

        // 3. 设置socket为监听状态（TCP特有）
        if (listen(_listensock, default_backlog))  // backlog指定等待连接队列长度
        {
            lg.LogMessage(Fatal, "listen socket error, errno code: %d, error string: %s\n", 
                         errno, strerror(errno));
            exit(Listen_Err);  // 监听错误退出
        }
        lg.LogMessage(Debug, "listen socket success, sockfd: %d\n", _listensock);
    }

    // 处理客户端连接的服务函数
    void Service(int sockfd)
    {
        char buffer[1024];  // 接收缓冲区
        
        // 持续进行IO操作
        while (true)
        {
            // 读取客户端数据
            ssize_t n = read(sockfd, buffer, sizeof(buffer) - 1);
            if (n > 0)  // 读取成功
            {
                buffer[n] = 0;  // 添加字符串结束符
                std::cout << "client say# " << buffer << std::endl;
                
                // 构造回显字符串
                std::string echo_string = "server echo# ";
                echo_string += buffer;
                
                // 回写给客户端
                write(sockfd, echo_string.c_str(), echo_string.size());
            }
            else if (n == 0)  // 对端关闭连接
            {
                lg.LogMessage(Info, "client quit...\n");
                break;
            }
            else  // 读取错误
            {
                lg.LogMessage(Error, "read socket error, errno code: %d, error string: %s\n", 
                             errno, strerror(errno));
                break;
            }
        }
    }

    // 启动服务器
    void Start()
    {
        _isrunning = true;  // 设置运行标志
        
        while (_isrunning)  // 主循环
        {
            // 4. 接受客户端连接
            struct sockaddr_in peer;  // 客户端地址信息
            socklen_t len = sizeof(peer);
            
            int sockfd = accept(_listensock, CONV(&peer), &len);
            if (sockfd < 0)  // 接受连接失败
            {
                lg.LogMessage(Warning, "accept socket error, errno code: %d, error string: %s\n", 
                             errno, strerror(errno));
                continue;  // 继续等待下一个连接
            }
            
            lg.LogMessage(Debug, "accept success, get n new sockfd: %d\n", sockfd);
            
            // 5. 为客户端提供服务
            Service(sockfd);  // 处理客户端请求
            
            close(sockfd);  // 关闭连接
        }
    }

    // 析构函数
    ~TcpServer()
    {
        // 可以在这里关闭_listensock，但通常由操作系统自动回收
    }

private:
    uint16_t _port;      // 服务器端口号
    int _listensock;     // 监听套接字描述符
    bool _isrunning;     // 服务器运行状态标志
};

TcpClient.cc

#include <iostream>
#include <string>
#include <cstring>    // 提供memset等字符串操作函数
#include <cstdlib>     // 提供基本工具函数
#include <unistd.h>    // 提供POSIX操作系统API
#include <sys/types.h> // 提供系统数据类型定义
#include <sys/socket.h> // 提供套接字相关函数和数据结构
#include <netinet/in.h> // 提供Internet地址族相关定义
#include <arpa/inet.h>  // 提供IP地址转换函数
#include "Comm.hpp"    // 自定义通信头文件
using namespace std;

// 使用说明函数
void Usage(const std::string &process)
{
    std::cout << "Usage: " << process << " server_ip server_port" << std::endl;
}

// 主函数：TCP客户端实现
// 参数：./tcp_client serverip serverport
int main(int argc, char *argv[])
{
    // 1. 参数检查
    if (argc != 3)
    {
        Usage(argv[0]);  // 打印使用说明
        return 1;        // 参数错误返回1
    }

    // 2. 解析命令行参数
    std::string serverip = argv[1];        // 获取服务器IP地址
    uint16_t serverport = stoi(argv[2]);  // 获取服务器端口号并转换为整数

    // 3. 创建客户端套接字
    // AF_INET: IPv4地址族
    // SOCK_STREAM: 流式套接字(TCP)
    // 0: 默认协议
    int sockfd = socket(AF_INET, SOCK_STREAM, 0);
    if(sockfd < 0)
    {
        cerr << "socket error" << endl;  // 套接字创建失败
        return 1;
    }

    // 4. 准备服务器地址结构体
    struct sockaddr_in server;
    memset(&server, 0, sizeof(server));  // 清空结构体
    server.sin_family = AF_INET;          // 设置为IPv4地址族
    server.sin_port = htons(serverport);  // 将端口号转换为网络字节序
    
    // 将点分十进制IP地址转换为网络字节序的二进制形式
    // inet_pton: p(表示presentation) to n(表示network)
    inet_pton(AF_INET, serverip.c_str(), &server.sin_addr);

    // 5. 连接服务器
    // CONV宏可能定义在Comm.hpp中，用于将sockaddr_in*转换为sockaddr*
    int n = connect(sockfd, CONV(&server), sizeof(server));
    if(n < 0)
    {
        cerr << "connect error" << endl;  // 连接失败
        return 2;
    }

    // 6. 连接成功后，进入通信循环
    while(true)
    {
        string inbuffer;  // 存储用户输入
        cout << "Please Enter# ";  // 提示用户输入
        getline(cin, inbuffer);    // 读取用户输入

        // 7. 向服务器发送数据
        ssize_t n = write(sockfd, inbuffer.c_str(), inbuffer.size());
        if(n > 0)  // 发送成功
        {
            // 8. 准备接收服务器响应
            char buffer[1024];  // 接收缓冲区
            
            // 读取服务器响应
            ssize_t m = read(sockfd, buffer, sizeof(buffer)-1);
            if(m > 0)  // 成功读取到数据
            {
                buffer[m] = 0;  // 添加字符串结束符
                cout << "get a echo messsge -> " << buffer << endl;  // 打印响应
            }
            else if(m == 0 || m < 0)  // 连接关闭或读取错误
            {
                break;  // 退出循环
            }
        }
        else  // 发送失败
        {
            break;  // 退出循环
        }
    }

    // 9. 关闭套接字
    close(sockfd);
    return 0;  // 正常退出
}

Comm.hpp

// 防止头文件被重复包含的预处理指令
#pragma once  

// 包含必要的系统头文件
#include <sys/types.h>      // 提供基本系统数据类型定义
#include <sys/socket.h>     // 提供socket相关函数和数据结构
#include <netinet/in.h>     // 提供Internet地址族相关定义
#include <arpa/inet.h>      // 提供IP地址转换函数

// 定义错误码枚举，用于标识不同类型的错误
enum {
    Usage_Err = 1,   // 用法错误（如参数错误）
    Socket_Err,      // 创建socket失败
    Bind_Err,        // 绑定地址失败
    Listen_Err       // 监听端口失败
};

// 定义类型转换宏：将任意指针转换为struct sockaddr*类型
// 用于简化socket API中地址结构的类型转换
#define CONV(addr_ptr) ((struct sockaddr *)addr_ptr)

nocopy.hpp

// 防止头文件被重复包含的预处理指令
// 这是C/C++中防止多重包含的标准做法
#pragma once  

// 包含标准输入输出流头文件
// 虽然当前类未直接使用iostream，但保留以备后续扩展
#include <iostream>  

// 定义一个名为nocopy的类
// 该类的设计目的是禁止对象的拷贝构造和拷贝赋值操作
class nocopy  
{
public:  // 公有成员访问权限区域

    // 默认构造函数
    // 使用空实现（因为不需要特殊初始化）
    nocopy() {}  

    // 删除拷贝构造函数
    // = delete语法表示显式禁止拷贝构造
    // 任何尝试拷贝该类型对象的操作都会导致编译错误
    nocopy(const nocopy&) = delete;  

    // 删除拷贝赋值运算符
    // = delete语法表示显式禁止拷贝赋值
    // 任何尝试赋值该类型对象的操作都会导致编译错误
    const nocopy& operator=(const nocopy&) = delete;  

    // 析构函数
    // 使用空实现（因为没有资源需要释放）
    // 声明为虚函数会更好（如果预期有继承）
    ~nocopy() {}  
};

// 该类典型用法：
// class MyResource : private nocopy { ... };
// 这样MyResource就自动获得了不可拷贝的特性
由于客户端不需要固定的端口号，因此不必调用 bind()，客户端的端口号由内核自动分配。

注意：

客户端不是不允许调用 bind()，只是没有必要显式调用 bind() 固定一个端口号，否则如果在同一台机器上启动多个客户端，就会出现端口号被占用导致不能正确建立连接；

服务器也不是必须调用 bind()，但如果服务器不调用 bind()，内核会自动给服务器分配监听端口，每次启动服务器时端口号都不一样，客户端要连接服务器就会遇到麻烦。

测试多个连接的情况：

再启动一个客户端尝试连接服务器，发现第二个客户端不能正确和服务器进行通信。分析原因是因为我们 accept 了一个请求之后，就在一直 while 循环尝试 read，没有继续调用 accept，导致不能接受新的请求。我们当前的 TCP 实现只能处理一个连接，这是不科学的。

2.3 `Echo Server`多进程版

InetAddr.hpp

#pragma once  // 防止头文件被重复包含

#include <iostream>      // 标准输入输出流
#include <string>        // 字符串操作
#include <sys/types.h>   // 系统数据类型定义
#include <sys/socket.h>  // 套接字相关函数和数据结构
#include <netinet/in.h>  // 互联网地址族定义
#include <arpa/inet.h>   // IP地址转换函数

// 网络地址封装类
class InetAddr {
public:
    // 构造函数，通过sockaddr_in结构体初始化
    // @param addr: 传入的sockaddr_in结构体引用
    InetAddr(struct sockaddr_in &addr) : _addr(addr) {
        // 将网络字节序的端口号转换为主机字节序
        _port = ntohs(_addr.sin_port);
        // 将网络字节序的IP地址转换为点分十进制字符串
        _ip = inet_ntoa(_addr.sin_addr);
    }

    // 获取IP地址字符串
    // @return: 返回IP地址字符串
    std::string Ip() { return _ip; }

    // 获取端口号
    // @return: 返回端口号
    uint16_t Port() { return _port; }

    // 生成调试信息字符串
    // @return: 返回"IP:端口"格式的字符串
    std::string PrintDebug() {
        std::string info = _ip;
        info += ":";
        info += std::to_string(_port);  // 例如 "127.0.0.1:4444"
        return info;
    }

    // 获取内部的sockaddr_in结构体引用
    // @return: 返回sockaddr_in结构体常引用
    const struct sockaddr_in& GetAddr() {
        return _addr;
    }

    // 重载==运算符，用于比较两个InetAddr对象
    // @param addr: 要比较的另一个InetAddr对象
    // @return: 如果IP和端口都相同返回true，否则false
    bool operator==(const InetAddr& addr) {
        return this->_ip == addr._ip && this->_port == addr._port;
    }

    // 析构函数
    ~InetAddr() {}

private:
    std::string _ip;       // 存储IP地址字符串
    uint16_t _port;        // 存储端口号
    struct sockaddr_in _addr;  // 存储原始的网络地址结构
};

TcpServer.hpp

#pragma once  // 防止头文件重复包含

// 包含必要的系统头文件
#include <iostream>
#include <string>
#include <cerrno>      // 错误号相关
#include <cstring>     // 字符串操作
#include <cstdlib>     // 标准库函数
#include <sys/types.h> // 系统数据类型
#include <sys/socket.h> // 套接字接口
#include <netinet/in.h> // 网络地址结构
#include <arpa/inet.h>  // IP地址转换
#include <sys/wait.h>   // 进程等待

// 包含自定义头文件
#include "Log.hpp"      // 日志系统
#include "nocopy.hpp"   // 禁止拷贝的基类
#include "Comm.hpp"     // 通用通信定义
#include "InetAddr.hpp" // IP地址处理

const static int default_backlog = 6; // 监听队列的最大长度

// TcpServer类，继承自nocopy表示禁止拷贝
class TcpServer : public nocopy
{
public:
    // 构造函数，初始化端口号和运行状态
    TcpServer(uint16_t port) : _port(port), _isrunning(false)
    {
    }

    // 初始化服务器
    void Init()
    {
        // 1. 创建监听套接字
        // AF_INET: IPv4地址族
        // SOCK_STREAM: 流式套接字(TCP)
        // 0: 默认协议
        _listensock = socket(AF_INET, SOCK_STREAM, 0);
        if (_listensock < 0)
        {
            // 创建失败记录日志并退出
            lg.LogMessage(Fatal, "create socket error, errno code: %d, error string: %s\n", 
                          errno, strerror(errno));
            exit(Fatal);
        }

        // 设置套接字选项，允许地址和端口重用
        int opt = 1;
        setsockopt(_listensock, SOL_SOCKET, SO_REUSEADDR | SO_REUSEPORT, &opt, sizeof(opt));
        lg.LogMessage(Debug, "create socket success, sockfd: %d\n", _listensock);

        // 2. 填充本地网络信息并绑定
        struct sockaddr_in local;
        memset(&local, 0, sizeof(local));  // 清空结构体
        local.sin_family = AF_INET;         // IPv4地址族
        local.sin_port = htons(_port);      // 端口号，转换为网络字节序
        local.sin_addr.s_addr = htonl(INADDR_ANY); // 监听所有网络接口

        // 绑定套接字到本地地址
        if (bind(_listensock, CONV(&local), sizeof(local)) != 0)
        {
            lg.LogMessage(Fatal, "bind socket error, errno code: %d, error string: %s\n", 
                          errno, strerror(errno));
            exit(Bind_Err);
        }
        lg.LogMessage(Debug, "bind socket success, sockfd: %d\n", _listensock);

        // 3. 设置套接字为监听状态
        if (listen(_listensock, default_backlog) != 0)
        {
            lg.LogMessage(Fatal, "listen socket error, errno code: %d, error string: %s\n", 
                          errno, strerror(errno));
            exit(Listen_Err);
        }
        lg.LogMessage(Debug, "listen socket success, sockfd: %d\n", _listensock);
    }

    // 处理客户端连接的服务函数
    void Service(int sockfd)
    {
        char buffer[1024];  // 接收缓冲区
        
        // 持续进行IO操作
        while (true)
        {
            // 从客户端读取数据
            ssize_t n = read(sockfd, buffer, sizeof(buffer) - 1);
            if (n > 0)  // 读取成功
            {
                buffer[n] = 0;  // 添加字符串结束符
                std::cout << "client say# " << buffer << std::endl;
                
                // 构造回显消息并发送
                std::string echo_string = "server echo# ";
                echo_string += buffer;
                write(sockfd, echo_string.c_str(), echo_string.size());
            }
            else if (n == 0)  // 客户端关闭连接
            {
                lg.LogMessage(Info, "client quit...\n");
                break;
            }
            else  // 读取错误
            {
                lg.LogMessage(Error, "read socket error, errno code: %d, error string: %s\n", 
                              errno, strerror(errno));
                break;
            }
        }
    }

    // 处理连接的多进程方法
    void ProcessConnection(int sockfd, struct sockaddr_in &peer)
    {
        // 创建子进程处理连接
        pid_t id = fork();
        if (id < 0)  // fork失败
        {
            close(sockfd);
            return;
        }
        else if (id == 0)  // 子进程
        {
            close(_listensock);  // 子进程不需要监听套接字
            
            // 二次fork创建孙子进程(避免僵尸进程)
            if (fork() > 0)
                exit(0);
                
            // 孙子进程(孤儿进程，由init进程接管)
            InetAddr addr(peer);  // 获取客户端地址信息
            lg.LogMessage(Info, "process connection: %s:%d\n", 
                          addr.Ip().c_str(), addr.Port());
            
            // 处理客户端请求
            Service(sockfd);
            close(sockfd);
            exit(0);
        }
        else  // 父进程
        {
            close(sockfd);  // 父进程不需要连接套接字
            // 等待子进程结束(避免僵尸进程)
            pid_t rid = waitpid(id, nullptr, 0);
            if (rid == id)
            {
                // 子进程已结束，无需特殊处理
            }
        }
    }

    // 启动服务器
    void Start()
    {
        _isrunning = true;
        while (_isrunning)
        {
            // 4. 接受客户端连接
            struct sockaddr_in peer;
            socklen_t len = sizeof(peer);
            int sockfd = accept(_listensock, CONV(&peer), &len);
            if (sockfd < 0)
            {
                lg.LogMessage(Warning, "accept socket error, errno code: %d, error string: %s\n", 
                              errno, strerror(errno));
                continue;  // 接受失败继续尝试
            }
            
            lg.LogMessage(Debug, "accept success, get n new sockfd: %d\n", sockfd);
            
            // 处理客户端连接
            ProcessConnection(sockfd, peer);
        }
    }

    // 析构函数
    ~TcpServer()
    {
        // 可以在这里添加资源清理代码
    }

private:
    uint16_t _port;     // 服务器监听端口
    int _listensock;    // 监听套接字描述符
    bool _isrunning;    // 服务器运行状态标志
};

2.4 `Echo Server`多线程版

Thread.hpp

#pragma once  // 防止头文件重复包含

// 包含必要的系统头文件和自定义头文件
#include <iostream>
#include <string>
#include <cerrno>      // 错误码相关
#include <cstring>     // 字符串操作
#include <cstdlib>     // 标准库函数
#include <sys/types.h> // 系统数据类型
#include <sys/socket.h> // 套接字相关
#include <netinet/in.h> // 网络地址结构
#include <arpa/inet.h>  // IP地址转换
#include <sys/wait.h>   // 进程等待
#include <pthread.h>    // 线程相关
#include "Log.hpp"      // 自定义日志模块
#include "nocopy.hpp"   // 禁止拷贝的基类
#include "Comm.hpp"     // 通用通信功能
#include "InetAddr.hpp" // 自定义网络地址类

const static int default_backlog = 6; // 监听队列的最大长度

// TCP服务器类，继承自nocopy（禁止拷贝）
class TcpServer : public nocopy
{
public:
    // 构造函数，初始化端口号和运行状态
    TcpServer(uint16_t port) : _port(port), _isrunning(false)
    {
    }

    // 初始化TCP服务器
    void Init()
    {
        // 1. 创建监听套接字
        _listensock = socket(AF_INET, SOCK_STREAM, 0); // IPv4, TCP协议
        if (_listensock < 0) // 创建失败处理
        {
            lg.LogMessage(Fatal, "create socket error, errno code: %d, error string: %s\n", 
                         errno, strerror(errno));
            exit(Fatal); // 严重错误，退出程序
        }
        
        // 设置套接字选项：地址和端口可重用
        int opt = 1;
        setsockopt(_listensock, SOL_SOCKET, SO_REUSEADDR | SO_REUSEPORT, &opt, sizeof(opt));
        lg.LogMessage(Debug, "create socket success, sockfd: %d\n", _listensock);

        // 2. 绑定本地地址和端口
        struct sockaddr_in local;
        memset(&local, 0, sizeof(local)); // 清空结构体
        local.sin_family = AF_INET;      // IPv4
        local.sin_port = htons(_port);    // 端口号（主机字节序转网络字节序）
        local.sin_addr.s_addr = htonl(INADDR_ANY); // 监听所有网络接口

        // 绑定套接字
        if (bind(_listensock, CONV(&local), sizeof(local)) != 0)
        {
            lg.LogMessage(Fatal, "bind socket error, errno code: %d, error string: %s\n", 
                         errno, strerror(errno));
            exit(Bind_Err); // 绑定失败，退出程序
        }
        lg.LogMessage(Debug, "bind socket success, sockfd: %d\n", _listensock);

        // 3. 设置套接字为监听状态
        if (listen(_listensock, default_backlog) != 0)
        {
            lg.LogMessage(Fatal, "listen socket error, errno code: %d, error string: %s\n", 
                         errno, strerror(errno));
            exit(Listen_Err); // 监听失败，退出程序
        }
        lg.LogMessage(Debug, "listen socket success, sockfd: %d\n", _listensock);
    }

    // 线程数据类，用于传递连接信息给线程
    class ThreadData
    {
    public:
        ThreadData(int sockfd, struct sockaddr_in addr)
            : _sockfd(sockfd), _addr(addr)
        {}
        ~ThreadData()
        {}
    public:
        int _sockfd;      // 连接套接字描述符
        InetAddr _addr;   // 客户端地址信息
    };

    // 静态服务方法，处理客户端连接
    static void Service(ThreadData &td)
    {
        char buffer[1024]; // 数据缓冲区
        
        // 持续处理客户端请求
        while (true)
        {
            // 读取客户端数据
            ssize_t n = read(td._sockfd, buffer, sizeof(buffer) - 1);
            if (n > 0) // 读取成功
            {
                buffer[n] = 0; // 添加字符串结束符
                std::cout << "client say# " << buffer << std::endl;
                
                // 构造回显消息
                std::string echo_string = "server echo# ";
                echo_string += buffer;
                
                // 发送回显消息
                write(td._sockfd, echo_string.c_str(), echo_string.size());
            }
            else if (n == 0) // 客户端关闭连接
            {
                lg.LogMessage(Info, "client[%s:%d] quit...\n", 
                             td._addr.Ip().c_str(), td._addr.Port());
                break;
            }
            else // 读取错误
            {
                lg.LogMessage(Error, "read socket error, errno code: %d, error string: %s\n", 
                             errno, strerror(errno));
                break;
            }
        }
    }

    // 线程执行函数（静态方法）
    static void *threadExcute(void *args)
    {
        pthread_detach(pthread_self()); // 分离线程（自动回收资源）
        ThreadData *td = static_cast<ThreadData *>(args); // 转换参数类型
        TcpServer::Service(*td); // 调用服务方法
        close(td->_sockfd);     // 关闭连接套接字
        delete td;             // 释放线程数据
        return nullptr;
    }

    // 处理新连接（多线程版本）
    void ProcessConnection(int sockfd, struct sockaddr_in &peer)
    {
        InetAddr addr(peer); // 转换地址格式
        pthread_t tid;
        ThreadData *td = new ThreadData(sockfd, peer); // 创建线程数据
        
        // 创建新线程处理连接
        pthread_create(&tid, nullptr, threadExcute, (void*)td);
    }

    // 启动服务器
    void Start()
    {
        _isrunning = true;
        
        // 主循环：接受并处理连接
        while (_isrunning)
        {
            // 4. 接受新连接
            struct sockaddr_in peer;
            socklen_t len = sizeof(peer);
            int sockfd = accept(_listensock, CONV(&peer), &len);
            
            if (sockfd < 0) // 接受连接失败
            {
                lg.LogMessage(Warning, "accept socket error, errno code: %d, error string: %s\n", 
                             errno, strerror(errno));
                continue; // 继续等待下一个连接
            }
            
            lg.LogMessage(Debug, "accept success, get n new sockfd: %d\n", sockfd);
            ProcessConnection(sockfd, peer); // 处理新连接
        }
    }

    // 析构函数
    ~TcpServer()
    {
        // TODO: 应该在这里关闭监听套接字
    }

private:
    uint16_t _port;      // 服务器监听端口
    int _listensock;     // 监听套接字描述符
    bool _isrunning;     // 服务器运行状态标志
};

2.5 多线程远程命令执行

Command.hpp

#pragma once  // 防止头文件被重复包含

#include <iostream>    // 标准输入输出流
#include <string>      // 字符串处理
#include <set>         // 集合容器
#include <unistd.h>    // POSIX操作系统API（用于recv/send等）

// 命令处理类
class Command
{
private:
    std::set<std::string> _safe_command;  // 允许执行的安全命令集合
    int _sockfd;                          // 关联的套接字文件描述符
    std::string _command;                 // 存储接收到的命令

public:
    // 默认构造函数
    Command() {}

    // 带参数的构造函数，初始化套接字并设置允许的安全命令
    Command(int sockfd) : _sockfd(sockfd)
    {
        // 初始化允许执行的安全命令集合（白名单）
        _safe_command.insert("ls");       // 列出目录内容
        _safe_command.insert("pwd");      // 显示当前工作目录
        _safe_command.insert("ls -l");    // 详细列出目录内容
        _safe_command.insert("ll");       // ls -l的别名（某些系统）
        _safe_command.insert("touch");     // 创建空文件
        _safe_command.insert("who");      // 显示已登录用户
        _safe_command.insert("whoami");    // 显示当前用户名
    }

    // 检查命令是否安全（是否在白名单中）
    bool IsSafe(const std::string &command)
    {
        // 在安全命令集合中查找该命令
        auto iter = _safe_command.find(command);
        if(iter == _safe_command.end()) 
            return false;  // 命令不在白名单中，不安全
        else 
            return true;  // 命令在白名单中，安全
    }

    // 执行命令并返回结果
    std::string Execute(const std::string &command)
    {
        // 首先检查命令是否安全
        if(!IsSafe(command)) 
            return "unsafe";  // 不安全命令直接返回

        // 使用popen执行命令并获取输出
        FILE *fp = popen(command.c_str(), "r");  // "r"表示读取命令输出
        if (fp == nullptr)
            return std::string();  // 执行失败返回空字符串

        char buffer[1024];         // 读取缓冲区
        std::string result;        // 存储命令执行结果

        // 逐行读取命令输出
        while (fgets(buffer, sizeof(buffer), fp))
        {
            result += buffer;      // 将每行输出追加到结果字符串
        }

        pclose(fp);               // 关闭管道
        return result;             // 返回执行结果
    }

    // 从套接字接收命令
    std::string RecvCommand()
    {
        char line[1024];  // 接收缓冲区
        
        // 从套接字接收数据（暂时简化处理，不考虑完整协议）
        ssize_t n = recv(_sockfd, line, sizeof(line) - 1, 0);
        
        if (n > 0)  // 接收成功
        {
            line[n] = 0;          // 添加字符串结束符
            return line;           // 返回接收到的命令
        }
        else       // 接收失败或连接关闭
        {
            return std::string();  // 返回空字符串
        }
    }

    // 通过套接字发送命令执行结果
    void SendCommand(std::string result)
    {
        // 如果结果为空，发送"done"（例如touch命令没有输出）
        if(result.empty()) 
            result = "done";  

        // 通过套接字发送结果
        send(_sockfd, result.c_str(), result.size(), 0);
    }

    // 析构函数
    ~Command()
    {
        // 目前没有需要特殊清理的资源
    }
};

Tcpserver.hpp

#pragma once  // 防止头文件重复包含

// 包含必要的系统头文件和自定义头文件
#include <iostream>
#include <string>
#include <cerrno>      // 错误号相关
#include <cstring>     // 字符串操作
#include <cstdlib>     // 标准库函数
#include <sys/types.h> // 系统数据类型
#include <sys/socket.h> // 套接字相关
#include <netinet/in.h> // 网络地址结构
#include <arpa/inet.h>  // IP地址转换
#include <sys/wait.h>   // 进程等待
#include <pthread.h>    // 线程相关
#include "Log.hpp"      // 日志模块
#include "nocopy.hpp"   // 禁止拷贝基类
#include "Comm.hpp"     // 通用通信模块
#include "InetAddr.hpp" // IP地址封装
#include "Command.hpp"  // 命令执行模块

const static int default_backlog = 6; // 监听队列的最大长度

// TCP服务器类，继承自nocopy（禁止拷贝）
class TcpServer : public nocopy
{
public:
    // 构造函数，初始化端口号和运行状态
    TcpServer(uint16_t port) : _port(port), _isrunning(false)
    {
    }

    // 初始化服务器
    void Init()
    {
        // 1. 创建socket文件描述符
        _listensock = socket(AF_INET, SOCK_STREAM, 0);
        if (_listensock < 0)
        {
            lg.LogMessage(Fatal, "create socket error, errno code: %d, error string: %s\n", 
                         errno, strerror(errno));
            exit(Fatal); // 创建失败则退出程序
        }
        
        // 设置socket选项：地址和端口可重用
        int opt = 1;
        setsockopt(_listensock, SOL_SOCKET, SO_REUSEADDR | SO_REUSEPORT, &opt, sizeof(opt));
        lg.LogMessage(Debug, "create socket success, sockfd: %d\n", _listensock);

        // 2. 填充本地网络信息并绑定
        struct sockaddr_in local;
        memset(&local, 0, sizeof(local)); // 清空结构体
        local.sin_family = AF_INET;       // IPv4协议
        local.sin_port = htons(_port);    // 端口号（主机字节序转网络字节序）
        local.sin_addr.s_addr = htonl(INADDR_ANY); // 监听所有网卡

        // 2.1 绑定socket
        if (bind(_listensock, CONV(&local), sizeof(local)) != 0)
        {
            lg.LogMessage(Fatal, "bind socket error, errno code: %d, error string: %s\n", 
                         errno, strerror(errno));
            exit(Bind_Err); // 绑定失败则退出程序
        }
        lg.LogMessage(Debug, "bind socket success, sockfd: %d\n", _listensock);

        // 3. 设置socket为监听状态（TCP特有）
        if (listen(_listensock, default_backlog) != 0)
        {
            lg.LogMessage(Fatal, "listen socket error, errno code: %d, error string: %s\n", 
                         errno, strerror(errno));
            exit(Listen_Err); // 监听失败则退出程序
        }
        lg.LogMessage(Debug, "listen socket success, sockfd: %d\n", _listensock);
    }

    // 线程数据类（用于传递数据给线程）
    class ThreadData
    {
    public:
        ThreadData(int sockfd, struct sockaddr_in addr)
            : _sockfd(sockfd), _addr(addr)
        {
        }
        ~ThreadData()
        {
        }
    public:
        int _sockfd;      // 客户端socket描述符
        InetAddr _addr;   // 客户端地址信息
    };

    // 服务处理函数（静态方法，处理客户端请求）
    static void Service(ThreadData &td)
    {
        char buffer[1024];
        // 持续进行IO通信
        while (true)
        {
            Command command(td._sockfd);  // 创建命令对象
            std::string commandstr = command.RecvCommand(); // 接收命令
            if (commandstr.empty())  // 如果接收为空则退出
                return;
                
            std::string result = command.Execute(commandstr); // 执行命令
            command.SendCommand(result); // 发送执行结果
        }
    }

    // 线程执行函数（静态方法）
    static void *threadExcute(void *args)
    {
        pthread_detach(pthread_self()); // 设置线程为分离状态
        ThreadData *td = static_cast<ThreadData *>(args); // 转换参数类型
        TcpServer::Service(*td);       // 调用服务处理函数
        close(td->_sockfd);            // 关闭socket
        delete td;                     // 释放线程数据
        return nullptr;
    }

    // 处理连接（创建线程处理每个客户端）
    void ProcessConnection(int sockfd, struct sockaddr_in &peer)
    {
        // v3 多线程版本
        InetAddr addr(peer);  // 封装客户端地址
        pthread_t tid;        // 线程ID
        ThreadData *td = new ThreadData(sockfd, peer); // 创建线程数据
        pthread_create(&tid, nullptr, threadExcute, (void *)td); // 创建线程
    }

    // 启动服务器
    void Start()
    {
        _isrunning = true;
        while (_isrunning)
        {
            // 4. 获取客户端连接
            struct sockaddr_in peer;
            socklen_t len = sizeof(peer);
            int sockfd = accept(_listensock, CONV(&peer), &len);
            if (sockfd < 0)
            {
                lg.LogMessage(Warning, "accept socket error, errno code: %d, error string: %s\n", 
                             errno, strerror(errno));
                continue; // 接受失败则继续尝试
            }
            lg.LogMessage(Debug, "accept success, get n new sockfd: %d\n", sockfd);
            ProcessConnection(sockfd, peer); // 处理客户端连接
        }
    }

    // 析构函数
    ~TcpServer()
    {
    }

private:
    uint16_t _port;      // 服务器端口号
    int _listensock;     // 监听socket描述符
    bool _isrunning;     // 服务器运行状态标志
};

2.6 `Echo Server`线程池版

TcpServer.hpp

#pragma once  // 防止头文件重复包含

// 引入必要的系统头文件和自定义头文件
#include <iostream>
#include <string>
#include <cerrno>      // 错误号相关
#include <cstring>     // 字符串操作
#include <cstdlib>     // 退出函数
#include <sys/types.h> // 系统数据类型
#include <sys/socket.h> // socket相关
#include <netinet/in.h> // 网络地址结构
#include <arpa/inet.h>  // 地址转换
#include <sys/wait.h>   // 进程等待
#include <pthread.h>    // 线程相关
#include <functional>   // 函数对象
#include "Log.hpp"      // 自定义日志模块
#include "nocopy.hpp"   // 禁止拷贝的基类
#include "Comm.hpp"     // 通用通信定义
#include "InetAddr.hpp" // IP地址封装
#include "ThreadPool.hpp" // 线程池

const static int default_backlog = 6; // 监听队列的最大长度

// Tcp服务器类，继承自nocopy（禁止拷贝）
class TcpServer : public nocopy
{
public:
    // 构造函数，初始化端口号和运行状态
    TcpServer(uint16_t port) : _port(port), _isrunning(false)
    {
    }

    // 初始化服务器
    void Init()
    {
        // 1. 创建socket文件描述符
        _listensock = socket(AF_INET, SOCK_STREAM, 0);
        if (_listensock < 0)
        {
            lg.LogMessage(Fatal, "create socket error, errno code: %d, error string: %s\n", 
                         errno, strerror(errno));
            exit(Fatal); // 创建失败直接退出
        }
        
        // 设置socket选项（地址重用）
        int opt = 1;
        setsockopt(_listensock, SOL_SOCKET, SO_REUSEADDR | SO_REUSEPORT, &opt, sizeof(opt));
        lg.LogMessage(Debug, "create socket success, sockfd: %d\n", _listensock);

        // 2. 填充本地网络信息并绑定
        struct sockaddr_in local;
        memset(&local, 0, sizeof(local)); // 清空结构体
        local.sin_family = AF_INET;        // IPv4协议
        local.sin_port = htons(_port);     // 端口号（主机序转网络序）
        local.sin_addr.s_addr = htonl(INADDR_ANY); // 监听所有IP地址

        // 绑定socket
        if (bind(_listensock, CONV(&local), sizeof(local)) != 0)
        {
            lg.LogMessage(Fatal, "bind socket error, errno code: %d, error string: %s\n", 
                         errno, strerror(errno));
            exit(Bind_Err); // 绑定失败退出
        }
        lg.LogMessage(Debug, "bind socket success, sockfd: %d\n", _listensock);

        // 3. 设置socket为监听状态（TCP特有）
        if (listen(_listensock, default_backlog) != 0)
        {
            lg.LogMessage(Fatal, "listen socket error, errno code: %d, error string: %s\n", 
                         errno, strerror(errno));
            exit(Listen_Err); // 监听失败退出
        }
        lg.LogMessage(Debug, "listen socket success, sockfd: %d\n", _listensock);
    }

    // 服务处理函数（处理单个连接）
    void Service(int sockfd, InetAddr addr)
    {
        char buffer[1024]; // 接收缓冲区
        
        // 持续进行IO操作
        while (true)
        {
            // 读取客户端数据
            ssize_t n = read(sockfd, buffer, sizeof(buffer) - 1);
            if (n > 0) // 读取成功
            {
                buffer[n] = 0; // 添加字符串结束符
                std::cout << "client say# " << buffer << std::endl;
                
                // 构造回显消息
                std::string echo_string = "server echo# ";
                echo_string += buffer;
                
                // 回写给客户端
                write(sockfd, echo_string.c_str(), echo_string.size());
            }
            else if (n == 0) // 对端关闭连接
            {
                lg.LogMessage(Info, "client[%s:%d] quit...\n", 
                             addr.Ip().c_str(), addr.Port());
                break;
            }
            else // 读取错误
            {
                lg.LogMessage(Error, "read socket error, errno code: %d, error string: %s\n", 
                             errno, strerror(errno));
                break;
            }
        }
    }

    // 处理新连接（将任务放入线程池）
    void ProcessConnection(int sockfd, struct sockaddr_in &peer)
    {
        using func_t = std::function<void()>; // 定义函数对象类型
        InetAddr addr(peer); // 封装客户端地址信息
        
        // 使用bind绑定Service函数和参数
        func_t func = std::bind(&TcpServer::Service, this, sockfd, addr);
        
        // 将任务推送到线程池
        ThreadPool<func_t>::GetInstance()->Push(func);
    }

    // 启动服务器
    void Start()
    {
        _isrunning = true;
        while (_isrunning)
        {
            // 4. 接受新连接
            struct sockaddr_in peer;
            socklen_t len = sizeof(peer);
            int sockfd = accept(_listensock, CONV(&peer), &len);
            
            if (sockfd < 0) // 接受失败
            {
                lg.LogMessage(Warning, "accept socket error, errno code: %d, error string: %s\n", 
                             errno, strerror(errno));
                continue; // 继续等待新连接
            }
            
            lg.LogMessage(Debug, "accept success, get n new sockfd: %d\n", sockfd);
            
            // 处理新连接
            ProcessConnection(sockfd, peer);
        }
        _isrunning = false;
    }

    // 析构函数
    ~TcpServer()
    {
        // 可以在这里添加资源释放代码
    }

private:
    uint16_t _port;     // 服务器端口号
    int _listensock;    // 监听socket文件描述符
    bool _isrunning;    // 服务器运行状态标志
};

计算机网络： Socket编程