目录
（2）接收连接与处理请求：accept→read/write
在网络编程的学习旅程中，TCP 协议是绕不开的核心内容。它作为一种面向连接的可靠传输协议，支撑着互联网中绝大多数的应用通信。本文将结合一套完整的 C++ 实现代码，从基本原理到具体实践，带你掌握 TCP 编程的全流程 —— 从 socket 创建到多进程并发处理，最终实现一个可交互的 "回声" 程序。
一、TCP 通信的核心逻辑
TCP（Transmission Control Protocol）的通信模型遵循固定的 "连接 - 传输 - 断开" 流程，核心特点是面向连接和可靠传输：
- 角色划分：通信双方分为服务器（被动等待连接）和客户端（主动发起连接）
- 连接建立：通过 "三次握手" 建立可靠连接，确保双方都做好通信准备
- 数据传输：基于字节流的方式传输数据，通过确认机制保证数据不丢失、不重复
- 连接关闭：通过 "四次挥手" 优雅关闭连接，确保双方数据都已传输完成
本次实现的 "回声程序" 是 TCP 编程的经典入门案例：客户端发送任意字符串，服务器接收后添加 "server echo#" 前缀返回，直观展示完整通信流程。
二、TCP 服务器编程步骤
服务器的核心功能是 "监听连接→接收请求→处理交互"，完整步骤如下：
步骤 1：创建监听 Socket
Socket（套接字）是网络通信的 "门户"，本质是操作系统提供的网络通信接口（文件描述符）。
// 创建TCP监听Socket
int listensockfd = socket(AF_INET, SOCK_STREAM, 0);
if (listensockfd < 0) {
// 错误处理：创建失败（如协议不支持）
perror("socket error");
exit(1);
}
参数解析
AF_INET：使用 IPv4 地址族（互联网最常用）SOCK_STREAM：指定为流式套接字（TCP 协议的特征）0：自动选择对应的数据传输协议（此处为 TCP）
步骤 2：绑定地址与端口（bind）
创建 Socket 后，需要将其与本机的具体 IP 和端口绑定，明确 "监听哪个地址的请求"。
// 准备地址结构（网络字节序）
struct sockaddr_in local_addr;
memset(&local_addr, 0, sizeof(local_addr));
local_addr.sin_family = AF_INET; // IPv4
local_addr.sin_port = htons(8081); // 端口（主机字节序→网络字节序）
local_addr.sin_addr.s_addr = INADDR_ANY; // 绑定所有本地IP（多网卡场景适用）
// 绑定操作
int ret = bind(listensockfd, (struct sockaddr*)&local_addr, sizeof(local_addr));
if (ret < 0) {
perror("bind error");
exit(2);
}
关键细节：
- 网络字节序：TCP 规定网络中数据必须使用大端字节序，
htons()（host to network short）用于端口转换 INADDR_ANY：表示绑定本机所有可用 IP（无需手动指定具体 IP，灵活适配多网卡环境）
步骤 3：设置监听状态（listen）
绑定完成后，需将 Socket 转为 "监听状态"，准备接收客户端的连接请求。
// 开始监听（BACKLOG=8：未完成连接队列的最大长度）
int ret = listen(listensockfd, 8);
if (ret < 0) {
perror("listen error");
exit(3);
}
BACKLOG 参数：限制正在进行三次握手（未完成连接）的最大数量，超过此值的新连接会被暂时拒绝。
步骤 4：接收客户端连接（accept）
监听状态的 Socket 可以通过accept()函数阻塞等待并接收客户端连接。
struct sockaddr_in client_addr; // 存储客户端地址
socklen_t client_addr_len = sizeof(client_addr);
// 阻塞等待新连接，返回与该客户端通信的Socket
int clientsockfd = accept(listensockfd, (struct sockaddr*)&client_addr, &client_addr_len);
if (clientsockfd < 0) {
perror("accept error");
continue; // 忽略错误，继续等待下一个连接
}
核心特性：
accept()是阻塞函数，若无新连接则一直等待- 成功返回新的 Socket 描述符（专门用于与当前客户端通信）
- 原监听 Socket（
listensockfd）继续用于接收其他连接
步骤 5：与客户端交互（read/write）
连接建立后，通过read()和write()实现数据收发。
char buffer[4096];
while (true) {
// 读取客户端数据
ssize_t n = read(clientsockfd, buffer, sizeof(buffer) - 1);
if (n > 0) { // 读取成功
buffer[n] = '\0'; // 手动添加字符串结束符
// 处理数据（示例：添加前缀后回送）
std::string response = "server: " + std::string(buffer);
write(clientsockfd, response.c_str(), response.size());
}
else if (n == 0) { // 客户端主动关闭连接
std::cout << "client closed" << std::endl;
break;
}
else { // 读取错误（如网络异常）
perror("read error");
break;
}
}
注意事项：
read()返回值需严格判断：正数为实际读取字节数，0 表示对方关闭，负数表示错误- 避免假设 " 一次
read()能获取完整数据 "（TCP 是流式协议，数据可能分多次到达）
步骤 6：关闭连接（close）
交互结束后，关闭 Socket 释放资源：
close(clientsockfd); // 关闭与客户端的连接Socket
// 服务器退出时关闭监听Socket
// close(listensockfd);
步骤 7：并发处理（可选但重要）
单进程服务器一次只能处理一个客户端，实际应用中需支持并发，常用方案：
- 多进程：通过
fork()创建子进程处理每个连接（隔离性好，资源消耗高） - 多线程：通过
pthread_create()创建线程（资源消耗低，需处理同步） - IO 多路复用：用
select/epoll（Linux）实现单进程处理多连接（高性能）
三、TCP 客户端编程步骤
客户端流程相对简单，核心是 "连接服务器→交互数据"：
步骤 1：创建客户端 Socket
与服务器类似，客户端也需要创建 Socket：
int sockfd = socket(AF_INET, SOCK_STREAM, 0);
if (sockfd < 0) {
perror("socket error");
exit(1);
}
步骤 2：连接服务器（connect）
客户端通过connect()向服务器发起连接请求（触发三次握手）。
struct sockaddr_in server_addr;
memset(&server_addr, 0, sizeof(server_addr));
server_addr.sin_family = AF_INET;
server_addr.sin_port = htons(8081); // 服务器端口
server_addr.sin_addr.s_addr = inet_addr("127.0.0.1"); // 服务器IP
int ret = connect(sockfd, (struct sockaddr*)&server_addr, sizeof(server_addr));
if (ret < 0) {
perror("connect error");
exit(1);
}
特点：connect()是阻塞函数，直到连接建立或失败才返回。
步骤 3：与服务器交互（read/write）
连接成功后，通过read()/write()与服务器通信：
std::string message;
char buffer[1024];
while (true) {
// 输入要发送的数据
std::cout << "input message: ";
getline(std::cin, message);
// 发送数据
ssize_t n = write(sockfd, message.c_str(), message.size());
if (n <= 0) break;
// 接收服务器响应
int m = read(sockfd, buffer, sizeof(buffer));
if (m > 0) {
buffer[m] = '\0';
std::cout << "server response: " << buffer << std::endl;
} else break;
}
步骤 4：关闭连接
close(sockfd);四、核心代码解析
1. 辅助工具：InetAddr 类（网络地址处理）
网络编程中，IP 地址和端口需要在 "网络字节序"（大端）和 "主机字节序"（可能为小端）之间转换，InetAddr类封装了这一高频操作：
#pragma once
#include <iostream>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#define CONV(v) (struct sockaddr *)(v)
class InetAddr {
private:
struct sockaddr_in _net_addr; // 网络字节序的地址结构
std::string _ip; // 主机字节序的IP字符串
uint16_t _port; // 主机字节序的端口号
// 端口从网络字节序转主机字节序
void PortNet2Host() { _port = ::ntohs(_net_addr.sin_port); }
// IP从网络字节序转主机字节序（点分十进制字符串）
void IpNet2Host() {
char ipbuffer[64];
::inet_ntop(AF_INET, &_net_addr.sin_addr, ipbuffer, sizeof(ipbuffer));
_ip = ipbuffer;
}
public:
// 从sockaddr_in初始化（接收客户端连接时使用）
InetAddr(const struct sockaddr_in &addr) : _net_addr(addr) {
PortNet2Host();
IpNet2Host();
}
// 获取IP:Port格式字符串（如127.0.0.1:8081）
std::string Addr() { return Ip() + ":" + std::to_string(Port()); }
// 其他实用接口
std::string Ip() { return _ip; }
uint16_t Port() { return _port; }
struct sockaddr *NetAddr() { return CONV(&_net_addr); }
};
核心作用：自动完成地址转换，让业务代码更简洁，避免重复处理字节序问题。
2. 服务器端实现：TcpServer 类
服务器的核心工作是 "监听连接→接收请求→处理请求"，TcpServer类封装了完整流程：
（1）初始化服务器：socket→bind→listen
class TcpServer {
private:
uint16_t _port; // 端口号
bool _running; // 运行状态标识
int _listensockfd; // 监听socket描述符
public:
TcpServer(int port = 8081) : _port(port), _running(false) {}
void InitServer() {
// 1. 创建监听socket（AF_INET：IPv4，SOCK_STREAM：TCP）
_listensockfd = socket(AF_INET, SOCK_STREAM, 0);
if (_listensockfd < 0) {
std::cout << "socket error" << std::endl;
exit(1);
}
// 2. 绑定地址（IP+端口）
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 = INADDR_ANY; // 绑定所有本地IP（多网卡场景适用）
int n = bind(_listensockfd, CONV(&local), sizeof(local));
if (n < 0) {
std::cout << "bind error" << std::endl;
exit(2);
}
// 3. 开始监听（BACKLOG=8：未完成连接队列最大长度）
n = listen(_listensockfd, 8);
if (n < 0) {
std::cout << "listen error" << std::endl;
exit(3);
}
}
};
关键函数解析：
socket()：创建用于网络通信的文件描述符（类似文件句柄），参数指定协议族（IPv4）和协议类型（TCP）bind()：将 socket 与特定地址绑定，INADDR_ANY表示监听本机所有 IPlisten()：将 socket 转为监听状态，BACKLOG限制同时建立连接的最大数量
（2）接收连接与处理请求：accept→read/write
class TcpServer {
// ... 省略前面代码 ...
public:
void Start() {
_running = true;
while (_running) {
// 接收客户端连接（阻塞等待新连接）
struct sockaddr_in peer;
socklen_t peerlen = sizeof(peer);
int sockfd = accept(_listensockfd, CONV(&peer), &peerlen);
if (sockfd < 0) {
std::cout << "accept error" << std::endl;
continue;
}
// 打印客户端地址
InetAddr addr(peer);
std::cout << "client into: " << addr.Addr() << std::endl;
// 多进程处理并发（核心）
pid_t id = fork();
if (id == 0) { // 子进程
close(_listensockfd); // 子进程不需要监听socket
// 二次fork：避免子进程成为僵尸进程（让孙子进程被系统收养）
if (fork() > 0) exit(0);
HandlerRequest(sockfd); // 处理当前客户端请求
exit(0);
}
close(sockfd); // 父进程关闭连接socket
waitpid(id, NULL, 0); // 回收子进程资源
}
}
// 处理客户端请求（回声逻辑）
void HandlerRequest(int sockfd) {
char inbuffer[4096];
while (true) {
// 读取客户端数据
ssize_t n = read(sockfd, inbuffer, sizeof(inbuffer) - 1);
if (n > 0) { // 读取成功
inbuffer[n] = 0; // 手动添加字符串结束符
std::string echo_str = "server echo#" + std::string(inbuffer);
write(sockfd, echo_str.c_str(), echo_str.size()); // 回送数据
std::cout << "server echo: " << inbuffer << std::endl;
}
else if (n == 0) { // 客户端关闭连接
std::cout << "client closed: " << sockfd << std::endl;
break;
}
else { // 读取错误
break;
}
}
close(sockfd); // 关闭连接
}
};
核心逻辑说明：
accept()：阻塞等待客户端连接，返回新的 socket 描述符（专门用于与该客户端通信）- 多进程并发：通过
fork()创建子进程处理每个客户端，父进程继续接收新连接；二次fork()避免僵尸进程（子进程退出后由系统回收） - 数据处理：
read()读取客户端数据，write()回送带前缀的回声，通过返回值判断通信状态（成功 / 关闭 / 错误）
3. 客户端实现：TcpClient
客户端流程相对简单，核心是 "创建 socket→连接服务器→收发数据"：
#include <iostream>
#include <cstring>
#include <string>
#include <unistd.h>
#include <arpa/inet.h>
#include <sys/socket.h>
int main(int argc, char *argv[]) {
// 解析命令行参数（服务器IP和端口）
if (argc != 3) {
std::cout << "Usage:./TcpClient <server_ip> <port>" << std::endl;
return 1;
}
std::string server_ip = argv[1];
int server_port = std::stoi(argv[2]);
// 1. 创建客户端socket
int sockfd = socket(AF_INET, SOCK_STREAM, 0);
if (sockfd < 0) {
std::cout << "Error in creating socket" << std::endl;
return 1;
}
// 2. 连接服务器（触发三次握手）
struct sockaddr_in server_addr;
memset(&server_addr, 0, sizeof(server_addr));
server_addr.sin_family = AF_INET;
server_addr.sin_port = htons(server_port); // 端口转网络字节序
server_addr.sin_addr.s_addr = inet_addr(server_ip.c_str()); // IP转网络字节序
int n = connect(sockfd, (struct sockaddr *)&server_addr, sizeof(server_addr));
if (n < 0) {
std::cout << "Error in connecting to server" << std::endl;
return 1;
}
// 3. 循环发送数据并接收回声
std::string message;
while (true) {
char inbuffer[1024];
std::cout << "input message to send to server: ";
getline(std::cin, message);
// 发送数据到服务器
n = write(sockfd, message.c_str(), message.size());
if (n <= 0) break;
// 接收服务器回声
int m = read(sockfd, inbuffer, 1024);
if (m > 0) {
inbuffer[m] = '\0';
std::cout << "Server response: " << inbuffer << std::endl;
} else break;
}
close(sockfd); // 关闭连接
return 0;
}
关键函数：connect()会触发 TCP 三次握手，阻塞直到连接建立或失败；成功后通过read()/write()与服务器交互。
4. 编译脚本：Makefile
为简化编译流程，使用 Makefile 一键生成服务器和客户端可执行文件：
.PHONY:all
all:server_tcp client_tcp # 目标：服务器和客户端
# 编译服务器（依赖TcpServer.cc，链接pthread库）
server_tcp:TcpServer.cc
g++ -o $@ $^ -std=c++17 -lpthread
# 编译客户端（依赖TcpClient.cc）
client_tcp:TcpClient.cc
g++ -o $@ $^ -std=c++17 -lpthread
.PHONY:clean
clean: # 清理生成的文件
rm -f client_tcp server_tcp
五、运行演示
步骤 1：编译程序
make # 生成server_tcp（服务器）和client_tcp（客户端）
步骤 2：启动服务器
./server_tcp # 默认监听8081端口
步骤 3：启动客户端（新终端）
./client_tcp 127.0.0.1 8081 # 连接本地服务器（127.0.0.1为本地回环地址）
步骤 4：交互测试
在客户端输入任意内容（如 "hello tcp"），会收到服务器返回的 "server echo#hello tcp"；服务器终端会同步打印接收的消息，效果如下：
# 客户端终端
input message to send to server: hello tcp
Server response: server echo#hello tcp
# 服务器终端
client into: 127.0.0.1:54321 # 客户端端口为随机分配
server echo: hello tcp
六、常见问题与解决方案
地址已在使用（Address already in use）
- 原因：服务器关闭后，端口会进入 TIME_WAIT 状态（默认保留 2MSL 时间），短期内无法重用
- 解决：创建 socket 后设置 SO_REUSEADDR 选项，允许端口重用：
int opt = 1; setsockopt(_listensockfd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));僵尸进程问题
- 原因：子进程退出后，父进程未及时回收其资源，导致进程残留
- 解决：除了代码中的二次
fork()，还可注册 SIGCHLD 信号处理函数，自动回收子进程：
signal(SIGCHLD, SIG_IGN); // 忽略SIGCHLD信号，系统自动回收子进程粘包问题
- 原因：TCP 是流式协议，数据无边界，多次发送的小数据可能被合并传输
- 解决：定义应用层协议（如 "数据长度 + 实际数据" 格式），确保接收方正确拆分数据。
七、扩展与进阶方向
错误处理增强：当前用
cout输出错误，可改用perror()结合errno打印更详细的错误原因（如 "bind error: Address already in use"）。线程池替代多进程：多进程资源消耗高，可改用线程池（提前创建固定数量的线程），减少动态创建销毁的开销。
配置化参数：将端口、BACKLOG 等参数通过命令行或配置文件传入，避免硬编码（如
./server_tcp -p 8080 -b 16）。功能扩展：基于现有框架实现文件传输（分块发送文件内容）、多客户端群聊（服务器转发消息）等功能。
IO 多路复用：使用
select/poll/epoll（Linux）实现单进程处理多连接，大幅提升并发性能（适用于高并发场景）。
八、总结
本文通过一个完整的 TCP 回声程序，展示了网络编程的核心流程：从socket创建、bind绑定、listen监听，到accept接收连接、read/write收发数据，再到多进程并发处理。这些基础操作是理解 HTTP 服务器、RPC 框架等复杂网络应用的基石。