C++实现简易TCP服务器与客户端的Linux套接字编程

本文还有配套的精品资源，点击获取

简介：本文介绍了如何在Linux系统下使用C++语言编写TCP网络通信程序，涵盖套接字的创建与管理、多线程处理以及命令行参数使用。我们将通过源代码文件 server.cpp 和 client.cpp ，演示一个简易的TCP服务器和客户端的实现流程。此外，还将探讨多线程技术在服务器端的应用，以实现并发连接的处理。通过本项目，读者将了解TCP协议的工作原理，掌握Linux环境下的网络编程基础。

1. C++在Linux下的网络编程

网络编程简介

在当今的信息时代，网络编程是IT专业人员必须掌握的基本技能之一，它涉及到使用编程语言和网络协议来构建能够相互通信的软件应用程序。Linux系统因其开源和稳定性，在服务器和嵌入式设备中广泛使用，而C++则因其性能强大和灵活性高，成为了网络编程的热门选择。

C++在Linux下的网络编程优势

C++在Linux下进行网络编程具有明显的优势。首先，C++具备面向对象的特性，使得代码模块化和复用性更强，有利于构建复杂的应用程序。其次，C++直接支持指针和内存操作，对于需要高效内存管理的网络编程来说，这一点至关重要。最后，Linux为C++提供了丰富的网络编程API，如Berkeley套接字接口，开发者可以利用这些接口进行底层网络通信的构建和管理。

网络编程的要点

本章将探讨C++在Linux下网络编程的基础知识和实践技巧，包括Linux下的套接字编程、多线程服务器的构建、网络协议的实现以及性能优化等方面。接下来，我们将逐一分析这些要点，并通过具体的代码示例，帮助读者深入理解C++在网络编程中的应用，为后续章节的深入学习打下坚实基础。

2. TCP协议的应用与原理

2.1 TCP协议基础

2.1.1 TCP协议的特性

TCP（Transmission Control Protocol，传输控制协议）是一种面向连接的、可靠的、基于字节流的传输层通信协议。它为数据传输提供了以下关键特性：

• 面向连接 ：在数据交换之前，TCP通过三次握手建立连接，保证了通信双方的可用性。
• 可靠性保证 ：TCP通过序列号、确认应答、超时重传等机制保证数据的准确无误地送达目的地。
• 流量控制 ：TCP可以调整发送速率以避免快速发送方淹没慢速接收方。
• 拥塞控制 ：TCP能够感知网络拥堵状况，并通过调整数据包发送速率来进行拥塞避免。
• 全双工通信 ：连接的双方可以同时发送和接收数据。

2.1.2 TCP连接的建立与断开

TCP连接的建立和断开是通过一系列的控制消息来完成的，具体体现在以下几个阶段：

• 三次握手 ：建立连接时，客户端和服务端通过发送SYN、SYN-ACK和ACK三个控制包来同步序列号和确认号，并建立连接。
• 数据传输 ：一旦连接建立，数据就可以在这两个方向上传输。
• 四次挥手 ：断开连接时，需要发送四个控制包，即一个FIN和一个ACK来终止每一方向的传输，然后释放连接。

2.2 TCP在数据传输中的作用

2.2.1 数据流控制与可靠性保证

数据流控制和可靠性保证是TCP协议的核心功能，具体包括以下几个方面：

• 序列号和确认应答 ：每个TCP段都有一个序列号和确认应答号，确保了数据的顺序和完整性。
• 重传机制 ：如果TCP段没有在预定时间内被接收方确认，发送方将重发该段。
• 校验和 ：每个TCP段都包含一个校验和字段，用于检测数据在传输过程中的任何损坏。

2.2.2 TCP与UDP的对比分析

用户数据报协议（UDP）是一种无连接的协议，其与TCP在多个方面存在显著差异，这些差异决定了各自的应用场景：

• 可靠性 ：TCP提供了可靠的数据传输，而UDP不保证数据的可靠传输，因此可能会丢失或乱序。
• 效率 ：UDP没有建立连接的开销，因此在效率上优于TCP，适用于对实时性要求高的应用。
• 连接状态 ：TCP维护连接状态信息，而UDP则没有。

TCP与UDP的对比表：

通过本节的介绍，我们可以深入理解TCP协议在提供稳定、可靠的数据传输服务中的作用与重要性。它不仅是一种技术实现，也是互联网通信不可或缺的基础设施之一。下节将深入探讨套接字编程，这是实现网络通信的基石。

3. 套接字编程基础

套接字编程是网络编程的核心，它允许程序之间通过网络进行通信。Linux提供了丰富的套接字API，供开发者使用。在本章节中，我们将深入了解Linux下的套接字编程，特别是C++在实现这些API时的特点和应用。

3.1 Linux下的套接字编程概述

在深入细节之前，首先了解Linux套接字编程的一些基本概念是非常重要的。

3.1.1 套接字的类型与选择

在Linux中，套接字主要有三种类型：流式套接字（SOCK_STREAM）、数据报套接字（SOCK_DGRAM）和原始套接字（SOCK_RAW）。流式套接字基于TCP协议，提供可靠的面向连接的服务；数据报套接字基于UDP协议，提供无连接的服务，数据包可能丢失或重复；原始套接字允许直接对网络层协议进行操作，常用于开发新的网络协议或者实现防火墙功能。

在选择套接字类型时，需要考虑应用程序的需要，例如是否需要面向连接的通信，是否可以接受数据包的丢失，以及是否需要对底层协议进行控制。

3.1.2 网络字节序与主机字节序

在网络通信中，字节序问题是一个不可忽视的问题。不同的硬件平台可能采用不同的字节序，即大端序（big-endian）或小端序（little-endian）。为了保证数据在网络中传输的一致性，Linux使用标准的网络字节序（大端序）进行数据传输。

在C++中，可以使用 htons() , htonl() , ntohs() , 和 ntohl() 函数来转换主机字节序和网络字节序。例如，当准备发送一个16位的整数时，需要先用 htons() 转换为主机到网络字节序。

3.2 基于C++的套接字接口实现

本小节我们将探索如何在C++中实现套接字接口，包括创建套接字，绑定地址，监听连接，接受连接以及发送和接收数据等。

3.2.1 套接字的创建与绑定

创建一个套接字很简单，使用 socket() 系统调用即可。其基本语法如下：

#include <sys/socket.h>

int socket(int domain, int type, int protocol);

这里， domain 指定了协议族，比如 AF_INET （IPv4）或 AF_INET6 （IPv6）； type 指定了套接字类型，例如 SOCK_STREAM 或 SOCK_DGRAM ； protocol 允许进一步指定协议类型，通常对于TCP和UDP，可以设为0。

创建套接字后，需要将其绑定到特定的IP地址和端口上，使用 bind() 函数：

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

int bind(int sockfd, const struct sockaddr *addr, socklen_t addrlen);

这里的 sockfd 是 socket() 函数返回的套接字描述符， addr 是一个指向 sockaddr 结构的指针，它包含了要绑定的IP地址和端口信息， addrlen 是 addr 的大小。

3.2.2 套接字的监听、接受与发送

一旦套接字绑定了地址和端口，就可以监听来自客户端的连接请求了。使用 listen() 函数来启用监听：

int listen(int sockfd, int backlog);

sockfd 是监听套接字的描述符， backlog 是操作系统内核在拒绝连接之前的已完成连接的队列长度。

对于TCP套接字，客户端连接通过 accept() 函数来接受：

int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen);

该函数返回一个新的套接字文件描述符，用于与客户端通信。 addr 和 addrlen 用于填充客户端地址信息。

数据的发送和接收，分别通过 send() 和 recv() 函数来完成：

#include <sys/socket.h>

ssize_t send(int sockfd, const void *buf, size_t len, int flags);
ssize_t recv(int sockfd, void *buf, size_t len, int flags);

sockfd 是通信套接字的描述符， buf 是数据缓冲区的指针， len 是希望发送或接收的字节数。 flags 可以控制发送或接收的行为，比如 MSG_OOB 表示发送或接收带外数据。

为了演示套接字编程的基本步骤，以下是一个简单的TCP服务器示例代码，使用C++实现：

#include <iostream>
#include <sys/socket.h>
#include <netinet/in.h>
#include <unistd.h>
#include <cstring>

int main() {
int sockfd = socket(AF_INET, SOCK_STREAM, 0);
if (sockfd < 0) {
std::cerr << "Unable to create socket" << std::endl;
return -1;
}
sockaddr_in serverAddr;
std::memset(&serverAddr, 0, sizeof(serverAddr));
serverAddr.sin_family = AF_INET;
serverAddr.sin_addr.s_addr = INADDR_ANY;
serverAddr.sin_port = htons(8080);

if (bind(sockfd, (struct sockaddr*)&serverAddr, sizeof(serverAddr)) < 0) {
std::cerr << "Unable to bind" << std::endl;
return -1;
}

if (listen(sockfd, 3) < 0) {
std::cerr << "Unable to listen" << std::endl;
return -1;
}

sockaddr_in clientAddr;
socklen_t clientAddrLength = sizeof(clientAddr);
int newsockfd = accept(sockfd, (struct sockaddr*)&clientAddr, &clientAddrLength);
if (newsockfd < 0) {
std::cerr << "Unable to accept" << std::endl;
return -1;
}

char buffer[1024];
ssize_t readSize = recv(newsockfd, buffer, sizeof(buffer), 0);
if (readSize > 0) {
std::cout << "Received data: " << std::string(buffer, readSize) << std::endl;
}

// Send response to the client
const char *response = "Hello from server";
send(newsockfd, response, strlen(response), 0);
close(newsockfd);
close(sockfd);
return 0;
}

此代码段首先创建了一个TCP流式套接字，绑定了IP地址和端口，并开始监听连接。当接收到一个连接请求时，它接受连接并接收客户端发送的数据，然后发送一个响应消息给客户端。最后，关闭套接字以释放资源。

通过以上内容的讲解，相信读者已对套接字编程有了初步的理解。在下一节中，我们将进一步探索如何使用多线程技术来处理并发连接，这是服务器端编程的一个重要主题。

4. 多线程技术应用

多线程技术是现代操作系统提供的用于并行处理任务的机制，它允许同时执行多个线程，提高应用程序的响应性和性能。在服务器编程中，多线程尤其重要，因为它们可以同时处理来自多个客户端的请求，从而实现高并发。本章将详细介绍多线程的基本概念，创建方法，以及在服务器编程中如何应用多线程技术。

4.1 线程的基本概念与创建

4.1.1 线程与进程的区别

在深入探讨多线程技术之前，首先需要理解线程与进程之间的区别。进程是一个执行中的程序实例，是操作系统进行资源分配和调度的一个独立单位。进程拥有独立的地址空间和系统资源，如文件描述符和内存。而线程是进程内部的一个执行单元，一个进程可以有多个线程。线程共享进程的地址空间和其他资源，因此线程间的通信比进程间通信更高效。

线程相较于进程有以下几点优势：

• 创建和销毁线程的开销比进程小。
• 线程间的通信比进程间通信更简单，因为它们共享地址空间。
• 线程可以利用多核处理器的优势，实现并行处理。

4.1.2 C++中的线程创建与管理

从C++11开始，C++标准库提供了对线程的支持。 std::thread 类位于 <thread> 头文件中，是C++中创建和管理线程的主要方式。

以下是一个简单的示例，展示如何使用 std::thread 创建一个线程：

#include <iostream>
#include <thread>

void print_number(int num) {
std::cout << "Number is " << num << std::endl;
}

int main() {
int my_number = 10;
std::thread my_thread(print_number, my_number);
my_thread.join(); // 等待线程完成
return 0;
}

这段代码创建了一个新的线程，运行 print_number 函数，并将 my_number 作为参数传递。 my_thread.join() 调用确保主函数会等待线程结束，这是多线程编程中的一个重要操作，保证线程的安全同步。

创建线程时，要注意异常安全性，因为线程在构造函数中启动，所以需要确保异常不会导致资源泄露。可以使用 try…catch 块捕获异常，并在捕获异常时安全地清理资源。

4.2 多线程在服务器编程中的应用

4.2.1 线程池的概念与实现

线程池是一种管理线程生命周期的技术，它预先创建一定数量的线程，将任务放入队列中，由这些线程依次执行。线程池可以减少线程创建和销毁的开销，并且可以有效地管理线程资源。

实现线程池通常涉及以下组件：

• 任务队列：用于存放待处理任务。
• 工作线程：从任务队列中取出任务并执行。
• 线程池管理器：负责线程的创建、任务分配和线程回收。

一个简单的线程池实现可以使用以下伪代码：

#include <vector>
#include <thread>
#include <queue>
#include <mutex>
#include <condition_variable>
#include <functional>
#include <future>

class ThreadPool {
public:
using Task = std::function<void()>;

explicit ThreadPool(size_t);

template<class F, class… Args>
auto enqueue(F&& f, Args&&… args)
-> std::future<typename std::result_of<F(Args…)>::type>;

~ThreadPool();

private:
// 需要实现的任务队列、工作线程的管理等
};

4.2.2 线程同步与数据共享问题

多线程编程中的一个主要问题是线程同步和数据共享。由于线程共享地址空间，如果没有适当的同步机制，那么多个线程可能会同时修改同一数据，导致不可预测的行为。

为了避免这些问题，可以使用互斥锁（ std::mutex ）来保证同一时刻只有一个线程可以访问共享资源。此外，C++11中引入的 std::atomic 类型为原子操作提供支持，允许进行不需要互斥锁的无锁同步。

考虑一个简单的计数器例子，多个线程需要对同一个计数器增加：

#include <iostream>
#include <thread>
#include <mutex>

std::mutex mtx;
int counter = 0;

void increase_counter() {
for (int i = 0; i < 1000; ++i) {
mtx.lock();
++counter;
mtx.unlock();
}
}

int main() {
std::vector<std::thread> threads;
for (int i = 0; i < 10; ++i) {
threads.emplace_back(increase_counter);
}
for (auto& t : threads) {
t.join();
}
std::cout << "Counter: " << counter << std::endl;
return 0;
}

在这个例子中，我们通过互斥锁 mtx 来保护对共享资源 counter 的访问，确保线程安全。

线程同步也可以通过其他机制，例如信号量（ std::counting_semaphore ），事件（ std::condition_variable ）等来实现。在实际开发中，应当根据具体需求选择合适的同步机制。

通过本章节的介绍，我们了解了多线程技术在服务器编程中的应用，及其在提升并发性能方面的优势。下一章我们将详细讨论命令行参数的解析与处理，这对于开发可配置的命令行工具至关重要。

5. 命令行参数传递

在操作系统中，命令行工具是常见的执行程序的方式，而这些工具往往需要通过命令行参数来进行配置。参数传递机制允许用户在执行程序时，通过输入一系列参数来控制程序的行为，这对于提高程序的灵活性和可配置性至关重要。在本章节中，我们将深入了解命令行参数的解析和处理方式，同时探索如何在C++中实现有效的参数传递和验证。

5.1 命令行参数的解析

5.1.1 参数解析的意义与方法

命令行参数是程序启动时从外部传入的参数，它们可以是选项标志、数据值或者其他控制程序运行的指令。参数解析的目的在于将这些传入的参数转换为程序内部可以理解和操作的数据。

常见的参数解析方法包括：

• 位置参数 ：按顺序解析命令行输入的参数。
• 标志参数 ：使用特定的字符或字符串作为参数的前缀，如 -h 或 –help 。
• 选项参数 ：与标志参数类似，但是通常会跟一个值，例如 -d /var/log 。

C++中处理命令行参数的常见方法是使用标准库中的 main 函数，它能够接收命令行参数：

int main(int argc, char* argv[]) {
// argc 表示参数个数，argv 是参数字符串数组
// 通过遍历 argv 数组可以获取所有传入的参数
}

5.1.2 C++中处理命令行参数的工具

C++提供了标准输入输出流（iostream）和标准库（Standard Library）来处理命令行参数。除了直接使用 main 函数的参数之外，还可以使用 <getopt.h> 库或第三方库如 Boost.Program_options 来进行更复杂的参数解析。

下面展示一个简单的例子，使用 main 函数的参数：

#include <iostream>
#include <string>

int main(int argc, char* argv[]) {
if (argc < 2) {
std::cout << "Usage: " << argv[0] << " [options] <file>" << std::endl;
return 1;
}
std::string option;
for (int i = 1; i < argc; ++i) {
if (argv[i][0] == '-') {
option = argv[i];
} else {
std::cout << "Processing file: " << argv[i] << std::endl;
// 处理文件
}
}
// 根据选项进行不同的处理逻辑
if (option == "-v") {
std::cout << "Verbosity mode enabled." << std::endl;
}
return 0;
}

在上述代码中，我们首先检查输入参数的数量是否符合要求，然后遍历每个参数。如果参数以 – 开头，我们将其识别为一个选项，并根据不同的选项执行不同的逻辑。

5.2 参数有效性验证与处理

5.2.1 输入验证的重要性

参数有效性验证是确保程序稳定运行和数据正确性的重要步骤。如果参数处理不当，可能会导致程序崩溃或产生不可预期的行为。因此，对传入的参数进行验证是必不可少的。

验证通常包括：

• 确认参数的数量是否正确
• 校验参数类型是否合法
• 检查参数值是否在合理的范围内
• 验证选项标志是否有效

5.2.2 参数处理的常见错误与应对策略

在处理命令行参数时，可能会遇到各种错误，例如：

• 参数不足或过多
• 无效的参数标志或值
• 依赖外部文件或资源时的缺失文件错误

针对这些问题，我们可以通过以下策略来处理：

• 提供详细的使用说明，帮助用户正确输入参数。
• 在代码中实现错误处理逻辑，如使用try-catch语句块来捕获可能发生的异常。
• 为关键函数调用提供默认参数值或合理的默认行为。

下面是一个更复杂的参数解析示例，使用了第三方库 Boost.Program_options ：

#include <boost/program_options.hpp>
#include <iostream>

namespace po = boost::program_options;

int main(int argc, char* argv[]) {
try {
std::string input_file;
int line_count;
po::options_description desc("Allowed options");
desc.add_options()
("help,h", "produce help message")
("input-file,i", po::value<std::string>(&input_file), "set input file")
("lines,l", po::value<int>(&line_count)->default_value(10), "number of lines to display")
;

po::variables_map vm;
po::store(po::parse_command_line(argc, argv, desc), vm);
po::notify(vm);

if (vm.count("help")) {
std::cout << desc << "\\n";
return 1;
}

if (vm.count("input-file")) {
std::cout << "Input file: " << input_file << "\\n";
} else {
std::cout << "No input file provided.\\n";
}

std::cout << "Number of lines to display: " << line_count << "\\n";
} catch(std::exception& e) {
std::cerr << "Error: " << e.what() << std::endl;
return 1;
} catch(…) {
std::cerr << "Unknown error!" << std::endl;
return 1;
}
return 0;
}

在这个例子中，我们使用了Boost库的 program_options 模块来处理命令行参数。程序不仅可以打印出帮助信息，还可以通过参数指定输入文件和需要展示的行数，并且能够捕获并处理潜在的异常。

通过以上内容，本章节展示了命令行参数传递的各个方面，从基本的参数解析方法，到复杂的参数验证和错误处理，为C++程序员提供了一个全面的参数处理指南。

6. 服务器与客户端通信流程

在现代网络应用中，服务器与客户端的通信是构成网络服务的核心部分。本章节将深入探讨服务器与客户端之间交互的流程，并详细解析如何设计和实现服务器端与客户端，以及它们之间的通信流程。

6.1 服务器端的设计与实现

服务器的主要任务是响应客户端的请求，并提供相应的服务。一个服务器端通常包括以下几个关键部分：

6.1.1 服务器的主循环逻辑

服务器的主循环逻辑是服务器程序的核心，负责监听来自客户端的连接请求，并根据不同的请求类型分发执行相应的服务。以下是设计主循环逻辑的基本步骤：

示例代码 展示了一个简单的服务器端主循环的实现：

#include <sys/socket.h>
#include <netinet/in.h>
#include <unistd.h>
#include <iostream>

int main() {
int server_fd, new_socket;
struct sockaddr_in address;
int opt = 1;
int addrlen = sizeof(address);
// 创建socket文件描述符
if ((server_fd = socket(AF_INET, SOCK_STREAM, 0)) == 0) {
perror("socket failed");
exit(EXIT_FAILURE);
}

// 绑定socket到端口8080
address.sin_family = AF_INET;
address.sin_addr.s_addr = INADDR_ANY;
address.sin_port = htons(8080);

if (bind(server_fd, (struct sockaddr *)&address, sizeof(address)) < 0) {
perror("bind failed");
exit(EXIT_FAILURE);
}

// 监听端口
if (listen(server_fd, 3) < 0) {
perror("listen");
exit(EXIT_FAILURE);
}

while(true) {
std::cout << "Waiting for connections…" << std::endl;

if ((new_socket = accept(server_fd, (struct sockaddr *)&address, (socklen_t*)&addrlen)) < 0) {
perror("accept");
exit(EXIT_FAILURE);
}

// 生成新线程来处理客户端连接
std::thread(handle_client, new_socket).detach();
}
return 0;
}

6.1.2 处理并发连接的策略

服务器需要同时处理多个客户端的连接请求。为实现这一目标，有几种策略可供选择：

在实现并发连接时，服务器需要考虑以下因素：

• 资源管理 ：确保及时释放不再使用的资源，避免内存泄漏。
• 同步机制 ：合理使用互斥锁等同步机制，防止数据竞争和条件竞争。
• 负载均衡 ：合理分配任务，避免过载的线程或进程导致服务器性能下降。

6.2 客户端的设计与实现

客户端是发起连接请求，并与服务器进行交互的程序。一个良好的客户端设计需要关注连接的建立、数据的发送与接收、错误处理等方面。

6.2.1 客户端的连接与交互流程

客户端的设计流程可概括为以下几个步骤：

示例代码 展示了一个简单的客户端与服务器通信的实现：

#include <sys/socket.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <iostream>

int main() {
int sock = 0;
struct sockaddr_in serv_addr;
char buffer[1024] = {0};

// 创建socket
if ((sock = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
std::cout << "\\n Socket creation error \\n";
return -1;
}

serv_addr.sin_family = AF_INET;
serv_addr.sin_port = htons(8080);

// 将IPv4和IPv6地址从文本转换为二进制形式
if(inet_pton(AF_INET, "127.0.0.1", &serv_addr.sin_addr) <= 0) {
std::cout << "\\nInvalid address/ Address not supported \\n";
return -1;
}

// 连接到服务器
if (connect(sock, (struct sockaddr *)&serv_addr, sizeof(serv_addr)) < 0) {
std::cout << "\\nConnection Failed \\n";
return -1;
}

// 发送数据
std::cout << "Enter message to send: ";
std::cin.getline(buffer, 1024);
send(sock, buffer, strlen(buffer), 0);
std::cout << "Message sent\\n";

// 接收数据
int valread = read(sock, buffer, 1024);
std::cout << "Server: " << buffer << std::endl;

// 关闭连接
close(sock);
return 0;
}

6.2.2 错误处理与异常管理

客户端在进行网络通信时，可能会遇到各种异常和错误情况，如网络延迟、断线、服务器无响应等。为了保证客户端的健壮性和用户体验，良好的错误处理和异常管理是必不可少的。

以下是客户端程序中常见的错误处理机制：

在实际开发中，应结合具体需求和环境，合理地设计错误处理策略，确保客户端程序的稳定运行和用户的良好体验。

7. Linux Berkeley套接字API使用详解

7.1 基本套接字API的使用

7.1.1 建立连接的socket函数

在Linux下使用C++进行网络编程时， socket() 函数是建立连接的基石，它会返回一个文件描述符用于后续操作。 socket() 函数的原型如下：

int socket(int domain, int type, int protocol);

• domain 参数定义了通信的协议族。例如，对于Internet协议族，应使用 AF_INET 。
• type 参数指定了套接字类型，比如面向连接的流式套接字使用 SOCK_STREAM 。
• protocol 参数表示要使用的具体协议，对于TCP协议，通常使用 IPPROTO_TCP 。

创建一个TCP套接字的示例代码如下：

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

int create_tcp_socket() {
int sock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
if (sock == -1) {
perror("socket");
return -1;
}
return sock;
}

在此代码中，创建套接字后，需要对套接字进行一系列设置和绑定操作，之后才能进行连接。

7.1.2 数据交换的send和recv函数

send() 和 recv() 是用于在已建立的连接上进行数据交换的函数。 send() 函数用于发送数据，而 recv() 函数用于接收数据。

send() 函数原型如下：

ssize_t send(int sockfd, const void *buf, size_t len, int flags);

• sockfd 是之前通过 socket() 创建的套接字文件描述符。
• buf 是指向包含要发送数据的缓冲区的指针。
• len 是要发送的数据长度。
• flags 用于修改 send() 的默认行为，一般设置为0。

recv() 函数原型如下：

ssize_t recv(int sockfd, void *buf, size_t len, int flags);

这里参数含义与 send() 类似，但是 flags 也可用于处理例如 MSG_OOB （接收带外数据）等特殊情况。

以下是一个发送和接收数据的示例：

#include <sys/types.h>
#include <sys/socket.h>
#include <unistd.h>

// 假设sockfd已经是一个有效的套接字描述符
void send_and_receive(int sockfd) {
const char *message = "Hello, World!";
char buffer[1024];

// 发送数据
if (send(sockfd, message, strlen(message), 0) == -1) {
perror("send");
}

// 接收数据
ssize_t bytes_received = recv(sockfd, buffer, sizeof(buffer), 0);
if (bytes_received == -1) {
perror("recv");
} else {
buffer[bytes_received] = '\\0'; // 确保字符串正确结束
printf("Received message: %s\\n", buffer);
}
}

7.2 高级套接字API的使用

7.2.1 非阻塞和异步IO操作

Linux Berkeley套接字API支持非阻塞IO和异步IO操作，这对于实现高性能和可伸缩的网络应用非常关键。对于非阻塞IO，我们通常使用 fcntl() 系统调用来改变套接字的IO模式。

例如，将文件描述符 sockfd 设置为非阻塞模式的代码如下：

int flags = fcntl(sockfd, F_GETFL, 0);
fcntl(sockfd, F_SETFL, flags | O_NONBLOCK);

使用非阻塞IO时， send() 和 recv() 函数在不能立即完成时会返回错误 EAGAIN 或 EWOULDBLOCK 。

7.2.2 套接字选项的配置与获取

套接字选项允许对套接字的行为进行精细控制。例如，可以获取和设置超时，启用或禁用地址重用等。使用 getsockopt() 和 setsockopt() 函数来配置这些选项。

下面是一个获取套接字接收缓冲区大小的例子：

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

void get_recv_buffer_size(int sockfd) {
int size;
socklen_t length = sizeof(size);

if (getsockopt(sockfd, SOL_SOCKET, SO_RCVBUF, &size, &length) == -1) {
perror("getsockopt");
} else {
printf("Receive buffer size: %d bytes\\n", size);
}
}

通过这些高级API，开发者可以优化网络程序的性能，使程序更加灵活和高效。

通过第七章的学习，你应已经掌握了Linux Berkeley套接字API的基础和高级用法，这将有助于你实现更加复杂的网络通信需求。

本文还有配套的精品资源，点击获取

简介：本文介绍了如何在Linux系统下使用C++语言编写TCP网络通信程序，涵盖套接字的创建与管理、多线程处理以及命令行参数使用。我们将通过源代码文件 server.cpp 和 client.cpp ，演示一个简易的TCP服务器和客户端的实现流程。此外，还将探讨多线程技术在服务器端的应用，以实现并发连接的处理。通过本项目，读者将了解TCP协议的工作原理，掌握Linux环境下的网络编程基础。

本文还有配套的精品资源，点击获取