1
#include <sys/socket.h>   // Linux
2
// #include <winsock2.h>   // Windows
3

4
// === TCP 服务器 ===
5
// 1. 创建 socket
6
int server_fd = socket(AF_INET, SOCK_STREAM, 0);  // TCP
7

8
// 2. 绑定地址
9
sockaddr_in addr{};
10
addr.sin_family = AF_INET;
11
addr.sin_addr.s_addr = INADDR_ANY;  // 监听所有网卡
12
addr.sin_port = htons(8080);         // 端口 8080（网络字节序）
13
bind(server_fd, (sockaddr*)&addr, sizeof(addr));
14

15
// 3. 监听
16
listen(server_fd, 128);  // backlog = 128（半连接/全连接队列大小）
17

18
// 4. 接受连接
19
sockaddr_in client_addr{};
20
socklen_t client_len = sizeof(client_addr);
21
int client_fd = accept(server_fd, (sockaddr*)&client_addr, &client_len);
22
// accept 返回一个新的 fd，用于和这个客户端通信
23

24
// 5. 收发数据
25
char buf[1024];
26
ssize_t n = recv(client_fd, buf, sizeof(buf), 0);
27
send(client_fd, "OK", 2, 0);
28

29
// 6. 关闭
30
close(client_fd);
31
close(server_fd);
32

33
// === TCP 客户端 ===
34
int sock = socket(AF_INET, SOCK_STREAM, 0);
35
sockaddr_in server_addr{};
36
server_addr.sin_family = AF_INET;
37
server_addr.sin_port = htons(8080);
38
inet_pton(AF_INET, "127.0.0.1", &server_addr.sin_addr);
39

40
connect(sock, (sockaddr*)&server_addr, sizeof(server_addr));
41
send(sock, "Hello", 5, 0);
42
close(sock);

1
// 游戏客户端：单独的网络线程 + 主线程消息队列
2
// （交叉引用 C++ Ch7 的 SPSC 无锁队列）
3

4
class NetworkThread {
5
    int _sock;
6
    SPSCQueue<NetMessage, 4096> _recv_queue;  // 网络线程 → 主线程
7
    SPSCQueue<NetMessage, 4096> _send_queue;  // 主线程 → 网络线程
8
    std::atomic<bool> _running{true};
9

10
public:
11
    void run() {
12
        while (_running.load()) {
13
            // 用 select/poll 检查读写就绪（客户端只有一个连接，不需要 epoll）
14
            pollfd pfd = {_sock, POLLIN | POLLOUT, 0};
15
            int ret = poll(&pfd, 1, 10);  // 10ms 超时
16

17
            if (pfd.revents & POLLIN) {
18
                // 有数据可读
19
                char buf[4096];
20
                int n = recv(_sock, buf, sizeof(buf), 0);
21
                if (n > 0) {
22
                    // 解析包 → 推入接收队列
23
                    NetMessage msg = parsePacket(buf, n);
24
                    _recv_queue.push(msg);
25
                }
26
            }
27

28
            // 发送队列中的数据
29
            NetMessage out;
30
            while (_send_queue.pop(out)) {
31
                auto data = serializePacket(out);
32
                send(_sock, data.data(), data.size(), 0);
33
            }
34
        }
35
    }
36

37
    // 主线程调用
38
    void sendMessage(const NetMessage& msg) { _send_queue.push(msg); }
39
    bool pollMessage(NetMessage& msg) { return _recv_queue.pop(msg); }
40
};
41

42
// 游戏主循环
43
void gameLoop() {
44
    NetMessage msg;
45
    while (netThread.pollMessage(msg)) {
46
        handleServerMessage(msg);  // 处理服务器消息
47
    }
48
}

1
// C++ RAII 封装（跨平台）
2
class Socket {
3
    int _fd = -1;
4
public:
5
    Socket(int domain, int type, int protocol = 0)
6
        : _fd(::socket(domain, type, protocol)) {
7
        if (_fd == -1) throw std::runtime_error("socket() failed");
8
    }
9

10
    ~Socket() { if (_fd != -1) ::close(_fd); }
11

12
    // 禁止拷贝，允许移动
13
    Socket(const Socket&) = delete;
14
    Socket& operator=(const Socket&) = delete;
15
    Socket(Socket&& other) noexcept : _fd(other._fd) { other._fd = -1; }
16
    Socket& operator=(Socket&& other) noexcept {
17
        if (this != &other) {
18
            if (_fd != -1) ::close(_fd);
19
            _fd = other._fd;
20
            other._fd = -1;
21
        }
22
        return *this;
23
    }
24

25
    int fd() const { return _fd; }
26
    int release() { int f = _fd; _fd = -1; return f; }
27
};