当前位置：首页 > news >正文

C++网络编程入门：从TCP原理到Socket API实战

news 2026/8/8 4:56:44

1. 项目概述：为什么从TCP通信开始学网络编程？

如果你刚开始接触C++网络编程，或者已经写过一些单机程序，想探索程序如何“开口说话”，那么从TCP通信入手绝对是最佳起点。这就像学开车先学手动挡，理解了离合、油门和换挡的配合，以后开自动挡或者更复杂的车型都会游刃有余。TCP（传输控制协议）是互联网的基石，我们每天用的网页浏览、文件传输、邮件收发，其底层可靠的数据流大多由它承载。用C++来实现TCP通信，不仅仅是调用几个API，更是理解“面向连接的、可靠的、基于字节流的”这些抽象概念如何落地成代码的过程。

很多人觉得网络编程门槛高，看到“套接字”、“三次握手”、“阻塞非阻塞”就头大。其实，它的核心模型非常直观：一个程序（服务器）在某处“监听”一个地址（IP和端口），另一个程序（客户端）主动“连接”到这个地址，然后两者就能通过一条“管道”（连接）互相发送和接收数据。C++的标准库本身不直接提供网络功能，这恰恰是它的优势所在——它迫使我们必须理解操作系统提供的原生接口（如Berkeley套接字），从而打下最扎实的基础。掌握了这套底层逻辑，以后无论使用Boost.Asio、Qt Network还是任何其他高级网络库，你都能清晰地知道它们在帮你做什么，出了问题也知道该从哪里排查。

通过这个项目，你将亲手搭建一个最简单的C++ TCP通信模型。我们会从原理讲起，把“三次握手”、“滑动窗口”这些术语翻译成你能直观理解的场景；然后，我们会用最朴素的C++和Socket API，一步步实现一个能双向聊天的客户端-服务器程序。过程中，我会分享那些官方手册里不会写的坑：比如为什么你的send函数返回了成功，但对方却没收到完整数据？bind失败时那个“Address already in use”到底该怎么处理？如何优雅地关闭连接而不留下“僵尸套接字”？这些经验，都是我在调试无数个网络程序后总结出来的干货。

2. TCP核心原理：不只是三次握手那么简单

在动手写代码之前，我们必须花点时间把TCP的核心工作机制吃透。很多人对TCP的印象停留在“三次握手建立连接，四次挥手断开连接”，这没错，但仅仅是冰山一角。TCP设计的终极目标是在不可靠的IP网络之上，提供一条可靠的、有序的、无差错的数据流通道。理解它是如何实现这个目标的，是写出健壮网络程序的关键。

2.1 连接的生命周期：从握手到挥手

让我们用打电话来类比TCP连接。三次握手的过程是这样的：

客户端发送SYN：相当于你拿起电话，拨打号码，说“喂，你好，我想找老王”。（SYN=1, seq=x）
服务器回复SYN-ACK：老王接起电话，说“你好，我就是老王，请讲”。（SYN=1, ACK=1, seq=y, ack=x+1）
客户端发送ACK：你确认对方是老王，说“好的，老王，我有件事...”。（ACK=1, seq=x+1, ack=y+1）

至此，连接建立，双方确认了彼此的初始序列号，可以开始通话（传输数据）。这个设计巧妙地解决了网络延迟导致的旧连接请求突然到达（旧SYN包）等问题，保证了连接的唯一性和同步。

数据传输阶段是TCP的精髓。每个发送的字节都被分配一个序列号。接收方每收到一段数据，都必须回送一个确认（ACK），告知对方“我已收到到第N字节之前的所有数据”。如果发送方在一定时间内没收到ACK，它会认为数据包丢失，从而重传。这就是可靠性的根本。此外，TCP还通过滑动窗口机制来进行流量控制，接收方通过告知自己的接收窗口大小，来控制发送方的发送速率，防止自己被过快的数据淹没。

四次挥手是终止连接的过程：

主动方（比如客户端）发送FIN，表示“我说完了”。
被动方（服务器）回复ACK，表示“我知道你说完了”。
被动方可能还有数据要发送，等它也说完了，再发送自己的FIN。
主动方回复ACK，连接关闭。

这里有个关键点：发送FIN的一方，在收到对方的ACK后，会进入TIME_WAIT状态，等待2MSL（最长报文段寿命的两倍）时间后才彻底关闭。这个状态是为了确保最后一个ACK能到达对方，并让网络中所有属于这个连接的旧报文都失效。很多新手写的服务器重启时遇到“Address already in use”错误，就是因为上一个连接的TIME_WAIT状态还没结束。

2.2 关键机制详解：可靠性是如何炼成的？

重传机制：TCP的重传不是简单的定时器。它采用了一种叫自适应重传的算法。它会动态测量数据包往返时间（RTT），并据此设置一个超时重传时间（RTO）。如果网络波动大，RTO会变大，避免不必要的重传；如果网络稳定，RTO会变小，能更快地检测丢包。在Linux内核中，这通常由Jacobson/Karels算法实现。

流量控制（滑动窗口）：窗口大小决定了发送方在未收到确认的情况下，最多能发送多少数据。它是由接收方的TCP接收缓冲区剩余空间决定的，并通过ACK包中的“窗口大小”字段动态通知发送方。这是一个反压机制，确保发送速度不会超过接收方的处理能力。

拥塞控制：这是TCP最复杂的部分之一，目的是防止过多的数据注入网络，导致路由器缓存溢出（即拥塞）。它通过一个“拥塞窗口”来限制发送速率。经典的算法如慢启动、拥塞避免、快速重传和快速恢复。简单来说，连接开始时，拥塞窗口指数增长（慢启动）；到达阈值后，转为线性增长（拥塞避免）；当通过重复ACK检测到丢包时，它认为网络可能只是轻微拥塞，会执行快速重传和快速恢复，而不是直接退回到慢启动。这些算法共同保证了TCP既能充分利用带宽，又能在拥塞时主动“刹车”，维护整个网络的健康。

注意：理解这些原理不是为了去实现它们（它们在内核中实现），而是为了在应用层编程时做出正确决策。例如，当你发现吞吐量上不去时，可能不是你的代码慢，而是接收窗口或拥塞窗口太小，这时可能需要调整系统级的TCP缓冲区参数。

3. 环境准备与Socket API精讲

我们将在Linux环境下进行开发，因为它的网络编程接口最标准、最清晰。Windows的Winsock API在概念上与之相似，但有一些前缀和初始化步骤的差异。使用C++，我们直接调用C语言的Socket API，这能让我们聚焦于网络编程的本质。

3.1 核心Socket API函数剖析

Socket编程围绕几个核心函数展开，它们就像一套组合拳。

socket()- 创建端点：这是第一步，创建一个通信端点（socket）。你需要指定三个参数：

domain（地址族）：我们使用AF_INET（IPv4）或AF_INET6（IPv6）。
type（套接字类型）：对于TCP，我们使用SOCK_STREAM（流式套接字）；对于UDP，则是SOCK_DGRAM（数据报套接字）。
protocol（协议）：通常填0，系统会根据前两个参数自动选择TCP或UDP。

int server_fd = socket(AF_INET, SOCK_STREAM, 0); if (server_fd < 0) { perror("socket creation failed"); exit(EXIT_FAILURE); }

bind()- 绑定地址：将socket绑定到一个具体的IP地址和端口号。对于服务器，这是必须的，它告诉系统“我将在哪个地址上提供服务”。

struct sockaddr_in address; address.sin_family = AF_INET; address.sin_addr.s_addr = INADDR_ANY; // 绑定到本机所有IP address.sin_port = htons(8080); // 端口号，htons将主机字节序转为网络字节序 if (bind(server_fd, (struct sockaddr*)&address, sizeof(address)) < 0) { perror("bind failed"); close(server_fd); exit(EXIT_FAILURE); }

listen()- 开始监听：将socket置于被动监听模式，等待客户端的连接请求。参数backlog指定了连接请求队列的最大长度。注意，这个队列存放的是已完成三次握手和未完成三次握手的连接总和，内核对其比例有分配。

if (listen(server_fd, 5) < 0) { // 队列长度为5 perror("listen failed"); close(server_fd); exit(EXIT_FAILURE); }

accept()- 接受连接：这是一个阻塞调用（默认情况下）。它会从监听队列中取出一个已建立的连接，并返回一个用于这个连接的新socket文件描述符。原监听socket继续用于接收新的连接。

int new_socket; int addrlen = sizeof(address); new_socket = accept(server_fd, (struct sockaddr*)&address, (socklen_t*)&addrlen); if (new_socket < 0) { perror("accept failed"); close(server_fd); exit(EXIT_FAILURE); } // 现在可以使用 new_socket 与客户端通信了

connect()- 发起连接：客户端用它来主动连接服务器。send()/recv()(或write()/read()) - 发送/接收数据：用于在已建立的连接上传输数据。对于TCP流，它们没有消息边界的概念，你发送的若干次send，对方可能一次recv就全部收到，也可能分多次收到。

close()- 关闭连接：关闭socket，释放资源。对于TCP，这会触发四次挥手过程。

3.2 字节序与地址结构：网络编程的“方言”

网络协议规定使用大端字节序（Big-Endian），即高位字节在前。而我们的主机可能是大端（如某些旧式服务器）也可能是小端（x86/x64架构）。因此，所有在网络中传输的多字节整数（如端口号、IP地址），都必须使用htons（主机到网络短整型）、htonl（主机到网络长整型）、ntohs、ntohl函数进行转换。

struct sockaddr_in是用于IPv4的地址结构体，包含地址族、端口号和IP地址。sockaddr是一个更通用的结构体，许多API（如bind,connect）为了兼容性，要求传入sockaddr*类型，所以我们需要进行强制类型转换。

4. 实战：构建一个简易TCP回声服务器

现在，我们把理论付诸实践，构建一个“回声服务器”（Echo Server）。它的功能很简单：客户端发送什么文本，服务器就原样发回什么文本。这是测试网络连接和基础逻辑的经典示例。

4.1 服务器端实现步骤详解

服务器的逻辑是一个无限循环，持续接受新连接，并为每个连接创建一个处理线程（或进程），实现并发。

第一步：创建、绑定和监听Socket这部分代码已在上一节展示。关键点：

使用SOCK_STREAM和IPPROTO_TCP（或0）创建TCP socket。
bind时，INADDR_ANY是一个特殊地址，表示绑定到本机所有网络接口。如果你只想让服务器被特定网卡访问，可以指定具体的IP。
listen的backlog参数不宜设置过大，通常5-10即可，具体取决于你期望的并发连接建立速率和内核版本。

第二步：主循环接受连接

while (true) { std::cout << "Waiting for new connection...\n"; int client_socket = accept(server_fd, (struct sockaddr*)&address, (socklen_t*)&addrlen); if (client_socket < 0) { std::cerr << "Accept failed. Error: " << strerror(errno) << std::endl; continue; // 接受失败，继续等待下一个连接，而不是退出 } // 获取客户端IP和端口信息 char client_ip[INET_ADDRSTRLEN]; inet_ntop(AF_INET, &address.sin_addr, client_ip, INET_ADDRSTRLEN); std::cout << "Connection accepted from " << client_ip << ":" << ntohs(address.sin_port) << std::endl; // 为每个新连接创建一个线程进行处理 std::thread client_thread(handle_client, client_socket); client_thread.detach(); // 分离线程，让其独立运行 }

这里我们使用了C++11的std::thread来实现并发。detach()让线程在后台运行，主线程可以立刻回去继续accept新的连接。注意，在生产环境中，你需要一个更健壮的线程管理机制，比如线程池，以避免频繁创建销毁线程的开销。

第三步：客户端处理函数handle_client这是服务器逻辑的核心。

void handle_client(int client_socket) { char buffer[1024] = {0}; // 接收缓冲区 int valread; // 循环读取客户端数据 while ((valread = recv(client_socket, buffer, sizeof(buffer) - 1, 0)) > 0) { buffer[valread] = '\0'; // 确保字符串终止 std::cout << "Received from client: " << buffer << std::endl; // 回声：将收到的数据发回客户端 send(client_socket, buffer, valread, 0); std::cout << "Echoed back to client." << std::endl; // 简单判断，如果客户端发送"exit"，则结束会话 if (strncmp("exit", buffer, 4) == 0) { std::cout << "Client requested to exit." << std::endl; break; } memset(buffer, 0, sizeof(buffer)); // 清空缓冲区 } if (valread == 0) { std::cout << "Client disconnected gracefully.\n"; } else if (valread < 0) { std::cerr << "recv error: " << strerror(errno) << std::endl; } close(client_socket); // 关闭客户端socket std::cout << "Connection closed.\n"; }

关键点解析：

缓冲区管理：我们使用固定大小的栈上数组作为缓冲区。sizeof(buffer)-1是为了预留一个位置给字符串终止符\0。在实际项目中，你可能需要动态缓冲区来处理不定长的消息。
recv的返回值：
- > 0：成功读取的字节数。
- = 0：对方已优雅地关闭了连接（发送了FIN）。这是正常的断开信号。
- < 0：发生错误，需要检查errno。
send的注意事项：send的返回值表示成功放入内核发送缓冲区的字节数，不一定等于你要求发送的长度。在非阻塞模式下，或者发送缓冲区满时，可能会只发送了一部分。因此，对于重要的数据，需要循环发送直到全部完成。在我们的简单示例中暂时忽略此问题。
连接关闭：处理完一个客户端后，务必close(client_socket)。这个调用会触发TCP的四次挥手。

4.2 客户端实现步骤详解

客户端逻辑更直接：连接、发送、接收、关闭。

#include <iostream> #include <cstring> #include <unistd.h> #include <arpa/inet.h> int main() { int sock = 0; struct sockaddr_in serv_addr; const char* hello = "Hello from client!"; char buffer[1024] = {0}; // 1. 创建Socket if ((sock = socket(AF_INET, SOCK_STREAM, 0)) < 0) { std::cerr << "Socket creation error" << std::endl; return -1; } serv_addr.sin_family = AF_INET; serv_addr.sin_port = htons(8080); // 服务器端口 // 2. 将IP地址从文本转换为二进制形式 if (inet_pton(AF_INET, "127.0.0.1", &serv_addr.sin_addr) <= 0) { // 连接本地服务器 std::cerr << "Invalid address / Address not supported" << std::endl; return -1; } // 3. 连接服务器 if (connect(sock, (struct sockaddr*)&serv_addr, sizeof(serv_addr)) < 0) { std::cerr << "Connection Failed. Is the server running?" << std::endl; return -1; } std::cout << "Connected to server successfully.\n"; // 4. 发送数据 send(sock, hello, strlen(hello), 0); std::cout << "Hello message sent.\n"; // 5. 接收回声 int valread = recv(sock, buffer, 1024, 0); std::cout << "Server echoed: " << buffer << std::endl; // 6. 发送退出指令 send(sock, "exit", 4, 0); std::cout << "Exit command sent.\n"; // 7. 关闭连接 close(sock); return 0; }

客户端关键点：

inet_pton函数将点分十进制的IP地址字符串（如"127.0.0.1"）转换为网络字节序的二进制形式。
connect是阻塞调用，它会发起TCP三次握手，成功返回则连接建立。
客户端同样需要注意send和recv的返回值处理。

5. 进阶议题：让程序更健壮、更高效

上面的例子是一个最基础的模型，但它脆弱且低效。要写出生产级别的网络程序，我们必须考虑更多。

5.1 处理TCP粘包与拆包

TCP是字节流协议，没有消息边界。你发送两次"Hello"和"World"，对方可能一次收到"HelloWorld"（粘包），也可能分三次收到"He"、"lloWo"、"rld"（拆包）。这是TCP的固有特性，不是bug。应用层必须自己定义消息边界。常见方法有：

定长消息：每条消息固定长度，不足则填充。简单但浪费带宽。
分隔符：用特殊字符（如换行符\n）作为消息结束标志。我们的回声服务器示例中，如果客户端一次发送多行文本，服务器就需要按\n来分割。但分隔符本身不能出现在消息内容中。
长度前缀：最常用的方法。在消息头部添加一个固定长度的字段（如4字节整数），用来表示后面消息体的长度。接收方先读这个长度N，然后再精确地读取N个字节。

// 发送方伪代码 std::string message = "Hello, World!"; uint32_t len = htonl(message.size()); // 转换为主机字节序 send(sock, &len, sizeof(len), 0); // 先发长度 send(sock, message.c_str(), message.size(), 0); // 再发内容 // 接收方伪代码 uint32_t len = 0; recv(sock, &len, sizeof(len), MSG_WAITALL); // 确保读满4字节 len = ntohl(len); std::vector<char> buffer(len); recv(sock, buffer.data(), len, MSG_WAITALL); // 确保读满len字节 std::string received_message(buffer.begin(), buffer.end());

注意，即使使用了MSG_WAITALL标志，也不能保证一次recv调用就能读满指定字节数（在信号中断等情况下），所以仍然需要循环读取。

5.2 I/O模型：从阻塞到多路复用

我们的简单服务器为每个连接创建一个线程（线程-per-connection模型）。当连接数成千上万时，线程上下文切换的开销将变得不可接受。这时需要更高效的I/O模型。

非阻塞I/O（Non-blocking I/O）：将socket设置为非阻塞模式（fcntl(sock, F_SETFL, O_NONBLOCK)）。调用accept、recv、send时，如果操作不能立即完成，会立即返回一个错误（EAGAIN或EWOULDBLOCK），而不是阻塞。程序需要不断轮询（polling）所有socket，效率仍然不高。
I/O多路复用（I/O Multiplexing）：这是构建高性能网络服务器的核心技术。它允许一个线程同时监视多个socket的文件描述符，当其中任何一个描述符就绪（可读、可写或有异常）时，程序才会被通知并进行处理。这样，一个线程就能管理成千上万的连接。主要系统调用有：
- select：最古老，有描述符数量限制（通常是1024），且每次调用需要在内核和用户空间之间复制整个描述符集合，效率较低。
- poll：解决了select的描述符数量限制，但同样有复制开销。
- epoll（Linux特有）：目前Linux下性能最好的多路复用机制。它使用一个文件描述符来管理多个描述符，通过“事件就绪通知”模式，避免了不必要的遍历和复制，效率极高。
使用epoll的基本步骤：
```
int epoll_fd = epoll_create1(0); // 创建epoll实例 struct epoll_event event, events[MAX_EVENTS]; // 将监听socket添加到epoll兴趣列表 event.events = EPOLLIN; // 监视可读事件 event.data.fd = server_fd; epoll_ctl(epoll_fd, EPOLL_CTL_ADD, server_fd, &event); while (true) { int nfds = epoll_wait(epoll_fd, events, MAX_EVENTS, -1); // 等待事件发生 for (int i = 0; i < nfds; ++i) { if (events[i].data.fd == server_fd) { // 监听socket可读，表示有新连接 int client_sock = accept(server_fd, ...); // 将新客户端socket也加入epoll监视 event.events = EPOLLIN | EPOLLET; // 边缘触发模式 event.data.fd = client_sock; epoll_ctl(epoll_fd, EPOLL_CTL_ADD, client_sock, &event); } else { // 客户端socket可读或可写 int client_sock = events[i].data.fd; // 处理该客户端的数据收发... } } }
```
异步I/O（Asynchronous I/O）：如Linux的AIO或Windows的IOCP。程序发起一个I/O操作后立即返回，当整个I/O操作（数据已在内核缓冲区和用户缓冲区之间完成拷贝）完成后，内核再通知程序。这是理论上最高效的模型，但编程模型复杂。

对于大多数C++项目，使用epoll（Linux）或IOCP（Windows）结合线程池，是构建高性能网络服务的常见选择。也可以直接使用成熟的网络库，如Boost.Asio，它封装了各操作系统的异步I/O机制，提供了统一的、面向对象的接口。

5.3 错误处理与资源管理

网络编程中，错误无处不在。健壮的程序必须处理所有可能的错误。

检查每个系统调用的返回值：这是铁律。socket,bind,listen,accept,connect,send,recv,close都可能失败。
理解errno：当调用失败时，全局变量errno会被设置为特定的错误码。使用perror()或strerror(errno)可以打印出可读的错误信息。常见的错误有：
- EADDRINUSE：bind失败，地址已被使用（可能是之前的连接处于TIME_WAIT状态）。
- ECONNREFUSED：connect失败，目标端口无服务监听。
- ECONNRESET：连接被对方强制重置（对方进程崩溃或调用了RST）。
- EAGAIN/EWOULDBLOCK：在非阻塞模式下，操作暂时无法完成。
资源泄漏：确保每个成功打开的socket（包括accept返回的新socket）最终都被close。在异常处理路径上也要记得关闭。在C++中，可以使用RAII（资源获取即初始化）技术，创建一个Socket类，在构造函数中创建socket，在析构函数中关闭它，利用栈展开自动释放资源。
优雅关闭：简单的close可能丢失数据。更优雅的方式是使用shutdown函数。shutdown(sock, SHUT_WR)关闭写的这一半，发送FIN，但还可以继续接收数据。等接收完所有数据后，再调用close。

6. 常见问题与调试技巧实录

即使理解了所有原理，实际编码和运行时还是会遇到各种光怪陆离的问题。下面是我在项目中踩过的一些坑和总结的调试方法。

6.1 连接建立失败

connect: Connection refused`：最常见。原因：
1. 服务器程序没运行。
2. 服务器IP或端口写错了。
3. 服务器bind的地址不是INADDR_ANY，而客户端连接的地址不对。
4. 防火墙阻止了连接。排查：在服务器端用netstat -tlnp命令查看是否有进程在监听目标端口。用telnet <服务器IP> <端口>测试连通性。
bind: Address already in use`：
1. 之前的服务器进程关闭后，socket处于TIME_WAIT状态（持续2MSL，通常1-4分钟）。
2. 另一个程序正在使用该端口。解决：
- 等待一会儿再重启。
- 在bind之前设置socket选项SO_REUSEADDR，允许重用处于TIME_WAIT状态的地址。
```
int opt = 1; if (setsockopt(server_fd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt))) { perror("setsockopt SO_REUSEADDR failed"); }
```

6.2 数据传输异常

数据发送不完整：如前所述，send的返回值可能小于请求发送的长度。必须循环发送。

ssize_t total_sent = 0; while (total_sent < len) { ssize_t sent = send(sock, data + total_sent, len - total_sent, 0); if (sent < 0) { // 处理错误，如果是EAGAIN/EWOULDBLOCK，可能需要等待或重试 break; } total_sent += sent; }

数据接收不完整/粘包：这是应用层协议设计问题，必须按前面讲的“长度前缀”等方法解决。不要指望一次recv调用就能收到一条完整消息。
recv返回0：对方已正常关闭连接（发送了FIN）。你的程序应该关闭本端的socket并清理资源。
recv阻塞太久或无响应：可能是网络问题，也可能是对方程序卡死。可以设置socket的接收超时选项SO_RCVTIMEO，或者使用非阻塞I/O/多路复用配合超时机制。

6.3 性能与并发问题

**accept: Too many open files**：系统文件描述符耗尽。每个socket都是一个文件描述符。可以通过ulimit -n`查看和修改进程能打开的最大文件描述符数。在高并发服务器中，需要调大这个限制。
CPU占用100%：如果在一个紧密循环中不断调用accept或recv（非阻塞模式下），会导致CPU空转。正确的做法是使用select/poll/epoll这样的I/O多路复用机制，让进程在无事件时睡眠。
内存泄漏：除了socket，为每个连接动态分配的内存（如缓冲区、对象）也要记得释放。使用valgrind工具进行内存检查。

6.4 实用调试工具

netstat/ss：查看网络连接状态、监听端口。netstat -tlnp看监听，netstat -tanp看所有TCP连接。
tcpdump/Wireshark：网络抓包神器。当逻辑理不清时，直接看网络上流动的原始数据包，能看到SYN、ACK、数据、FIN，一切清清楚楚。这是调试网络程序的终极武器。
strace/ltrace：跟踪进程的系统调用和库函数调用，可以看到你的程序何时调用了socket、bind、send，参数和返回值是什么。
telnet/nc(netcat)：手动模拟TCP客户端，快速测试服务器是否响应。例如：nc -v 127.0.0.1 8080。

从最基本的Socket API调用，到TCP协议的可靠传输机制，再到处理粘包、选择I/O模型和调试排错，这条路充满了细节。我个人的体会是，网络编程的复杂性不在于单个API有多难，而在于对“状态”和“边界”的精确管理。连接的状态（建立、传输、关闭）、数据流的边界、缓冲区的管理、错误的发生点，这些都需要程序员时刻保持清醒。最好的学习方式就是动手，把这个回声服务器跑起来，然后用tcpdump看看握手挥手的过程，修改代码故意制造粘包，再实现一个长度前缀协议来解决它。当你能够从容地处理EAGAIN错误，并设计出一个清晰的应用层协议时，你就真正入门了。下一步，你可以尝试用epoll重写这个服务器以支持万级并发，或者探索Boost.Asio这样的现代C++网络库，它们用更优雅的方式封装了这些底层细节，让你能更专注于业务逻辑。

查看全文

http://www.cnnetsun.cn/news/3902782.html