C++学习32、网络编程

网络编程在现代软件开发中扮演着至关重要的角色，无论是开发桌面应用、Web服务，还是移动应用，网络编程都是不可或缺的一部分。C++作为一种高效且灵活的编程语言，在网络编程领域有着广泛的应用。本文将详细介绍如何使用C++进行网络编程，包括套接字编程的基本概念、TCP/IP协议、UDP协议以及实际代码示例。

一、网络编程基础

1.1 网络编程简介

网络编程是指通过编程的方式实现网络通信。网络通信的本质是数据交换，而数据交换需要遵循一定的协议。在网络编程中，我们常用的协议有TCP/IP协议和UDP协议。

1.1.1 IP地址

IP地址，即互联网协议地址，是用于标识网络上设备（如计算机、打印机、智能手机等）的数字标签。这些地址允许设备在互联网上相互通信。IP地址有两种主要版本：IPv4和IPv6。

IPv4：这是第四版互联网协议地址，由32位二进制数组成，通常被划分为四个8位（一个字节）的十进制数，并由点号分隔。例如，192.168.1.1是一个常见的IPv4地址。由于IPv4地址的有限性（总共约42亿个唯一地址），随着互联网的扩张，地址耗尽的问题变得日益严重。
IPv6：为了应对IPv4地址耗尽的问题，开发了第六版互联网协议地址（IPv6）。IPv6地址由128位二进制数组成，通常表示为八个16位的十六进制数，由冒号分隔。例如，2001:0db8:85a3:0000:0000:8a2e:0370:7334是一个IPv6地址。IPv6提供了约3.4×10^38个唯一地址，足以满足全球互联网设备的需要。

1.1.2 端口号

端口号是一个数字标识符，用于区分运行在同一台计算机上的不同网络服务或应用程序。每个端口号都与一个特定的服务或进程相关联，并且当客户端尝试与该服务通信时，它会指定相应的端口号。

范围：端口号的范围是从0到65535（对于16位端口号）。其中，0到1023是知名端口（也称为系统端口或保留端口），这些端口被分配给广泛使用的服务，如HTTP（80）、HTTPS（443）、FTP（21）等。1024到49151是注册端口，这些端口可以由用户或组织注册，以用于特定的服务。49152到65535是动态端口或私有端口，这些端口通常用于临时通信，并且不需要在IANA（互联网号码分配机构）注册。
用途：端口号在网络通信中起着至关重要的作用，因为它们允许计算机上的操作系统将传入的数据包路由到正确的应用程序或服务。例如，当浏览器尝试访问网页时，它会向服务器的80端口发送HTTP请求。如果服务器正在监听该端口，它就会接受请求并返回网页内容。

1.2 TCP/IP协议

TCP/IP协议（Transmission Control Protocol/Internet Protocol）是一种可靠的、面向连接的通信协议。TCP协议通过三次握手建立连接，通过四次挥手断开连接，确保数据传输的可靠性和顺序性。IP协议负责将数据报从源主机传输到目的主机。
TCP/IP协议栈按照功能被分为多个层次，这些层次从上到下依次是：

应用层：为应用程序提供网络服务。常见的协议包括HTTP（Hypertext Transfer Protocol，超文本传输协议）、FTP（File Transfer Protocol，文件传输协议）、SMTP（Simple Mail Transfer Protocol，简单邮件传输协议）等。
传输层：负责提供端到端的数据传输服务。主要协议是TCP（Transmission Control Protocol，传输控制协议）和UDP（User Datagram Protocol，用户数据报协议）。
网络层：负责将数据包从源设备路由到目标设备。IP（Internet Protocol，互联网协议）是网络层的核心协议，它负责主机间数据的路由和网络数据的传输存储。
链路层（也称为数据链路层或物理层）：负责在物理媒介上传输原始比特流。

TCP/IP协议的关键原理：

分层结构：TCP/IP协议栈按照功能被分为多个层次，每一层都调用其下一层提供的网络服务来完成自己的需求。
数据封装：当数据从应用层开始传输时，它会被封装成数据包，并在每个层添加相应的首部信息。这些首部包含了源地址、目的地址、端口号等关键信息，用于识别和路由数据包。
端到端通信：TCP/IP协议支持端到端的通信，即数据包从发送端到接收端的整个传输过程中，始终保持着源端和目的端的连接。
可靠性与效率：TCP协议通过序列号、确认机制和超时重传等机制来确保数据的可靠传输；而UDP协议则提供了更快的数据传输速度，但不保证数据的可靠性。

1.3 UDP协议

UDP协议（User Datagram Protocol）是一种不可靠的、无连接的通信协议。UDP协议不保证数据报按顺序到达，也不保证数据报不会丢失。因此，UDP协议通常用于对实时性要求较高但对可靠性要求不高的应用，如视频流、音频流等。

1.3.1 UDP的主要特点

无连接：UDP不需要建立连接就可以直接发送数据，没有TCP中的三次握手过程，因此减少了网络延迟。
不可靠：UDP不提供数据包的确认、重传或排序功能。如果数据包丢失、重复或乱序，UDP不会进行处理，这可能导致数据的不完整性。
面向数据报：每个数据报都是独立的，包含完整的源端口、目的端口、长度、校验和等信息。UDP协议以数据报为单位进行数据传输，每个数据报都有明确的大小和边界。
低开销：由于不需要维护连接状态和复杂的错误控制机制，UDP的头部非常简单，只有8个字节，因此传输效率较高。
广播支持：UDP支持广播和多播，可以将数据同时发送到多个接收者，这在某些应用场景中非常有用。

1.3.2 UDP协议的报文结构

UDP的报文包括两个部分：报文头和数据。报文头固定为8个字节，各个字段的含义如下：

源端口号（2字节）：标识发送方的应用程序端口。如果不需要源端口，可以设置为0。
目的端口号（2字节）：标识接收方的应用程序端口，必须设置一个有效的端口号。
长度（2字节）：表示整个UDP报文段的长度（包括报文头和数据），最小值为8字节（仅报文头）。
校验和（2字节）：用于检测UDP报文头和数据在传输过程中是否发生了改变。这个字段是可选的，如果设置为0，则表示没有校验和。

1.3.3 UDP协议的通信方式

UDP支持三种主要的通信方式：单播（Unicast）、广播（Broadcast）、组播（Multicast）。

单播：从一个发送者到一个特定接收者的点对点通信。大多数基于TCP/IP的应用程序都使用单播，如Web浏览、电子邮件等。单播的优点是高效、简单，数据直接从源发送到目的地，没有多余的复制和传输。
广播：发送者将数据包发送到本地网络中的所有主机。广播的应用场景包括DHCP（动态主机配置协议）、ARP（地址解析协议）、路由器发现等。广播的优点是实现简单，适用于局域网内的快速信息传播；缺点是会将数据包发送到网络中的每一个设备，即使这些设备并不需要该数据，这可能会导致网络拥塞。另外，广播不能跨越路由器，容易被监听，可能会泄露敏感信息。
组播：一种一对多或多对多的通信方式，发送者将数据包发送到一组特定的接收者，接收者通过加入一个组播组来接收数据。组播的应用场景包括IPTV、在线直播、视频会议等。组播的优点是节省带宽，数据在网络中仅传输一次，然后由路由器等设备负责将数据复制并分发给多个接收者；另外，组播的可扩展性强，可以轻松地添加或移除接收者，而不需要修改发送者的行为。缺点是实现和配置复杂，需要路由器和交换机等设备支持组播路由，并正确配置组播组和相关的网络设备。

1.3.4 UDP协议的应用场景

由于UDP协议具有低延迟、高效率和简单的特性，它在多种应用场景中被广泛使用。以下是一些典型的应用场景：

实时视频/音频流：如VoIP、直播等，这些应用对延迟的要求很高，可以容忍少量的数据丢失。
在线游戏：游戏中玩家的操作和状态更新需要快速响应，使用UDP可以减少延迟。
DNS查询：域名系统查询通常使用UDP，因为查询请求和响应都很小，且不要求绝对的可靠性。
NTP（网络时间协议）：用于同步计算机时钟，对数据的一致性和准确性要求不高。

1.4 C++的网络编程环境

在C++中进行网络编程，需要用到一些系统提供的网络库。在Windows平台上，通常使用Winsock库；在Linux平台上，通常使用POSIX标准的套接字API。

Windows平台上的Winsock库：
Winsock库是Windows平台上用于网络编程的API，它提供了一套用于网络通信的函数和数据结构。在使用Winsock库之前，需要包含头文件<winsock2.h>，并链接到Ws2_32.lib库。
Linux平台上的套接字API：
在Linux平台上，套接字API遵循POSIX标准，提供了一套用于网络通信的函数和数据结构。在使用套接字API之前，需要包含头文件<sys/types.h>、<sys/socket.h>、<netinet/in.h>和<arpa/inet.h>（或使用<netinet/in.h>中的inet_addr函数时需要包含<arpa/inet.h>）。

1.5 套接字（Socket）

套接字是支持TCP/IP协议的网络通信的端点，它提供了一种抽象的、统一的接口，使得不同的主机之间可以进行数据传输。套接字分为流式套接字（SOCK_STREAM，对应于TCP协议）和数据报套接字（SOCK_DGRAM，对应于UDP协议）。

流套接字（SOCK_STREAM）：基于TCP协议，提供可靠的、面向连接的通信。
数据报套接字（SOCK_DGRAM）：基于UDP协议，提供不可靠的、无连接的通信。

地址族：

IPv4地址族（AF_INET）：用于IPv4网络通信。
IPv6地址族（AF_INET6）：用于IPv6网络通信。

使用步骤：

1.加载Winsock库（Windows特有）：
在Windows平台上，使用套接字之前需要加载Winsock库，通常通过WSAStartup函数完成。

2.创建套接字：
使用socket函数创建一个套接字，指定地址族、套接字类型和协议。

3.绑定套接字（服务器特有）：
服务器通常需要将套接字绑定到一个特定的IP地址和端口号上，以便客户端能够连接到它。这通过bind函数完成。

4.监听连接（服务器特有）：
服务器使用listen函数将套接字设置为监听状态，准备接受客户端的连接请求。

5.接受连接（服务器特有）：
服务器使用accept函数接受一个客户端的连接请求，并返回一个新的套接字用于与该客户端通信。

6.建立连接（客户端特有）：
客户端使用connect函数尝试连接到服务器。

7.发送和接收数据：
使用send或write函数发送数据，使用recv或read函数接收数据。

8.关闭套接字：
使用closesocket函数关闭套接字，释放资源。

9.清理Winsock库（Windows特有）：
在程序结束时，使用WSACleanup函数清理Winsock库。

二、C++网络编程示例

下面将分别给出TCP和UDP协议的C++网络编程示例。

2.1 TCP协议示例

TCP协议示例包括服务器端和客户端两个部分。服务器端负责监听连接请求，接受连接，并发送和接收数据；客户端负责发起连接请求，发送和接收数据。

2.1.1 TCP服务器端示例

#include <iostream>
#include <winsock2.h>
#pragma comment(lib, "Ws2_32.lib")

#define PORT 8080
#define BUFFER_SIZE 1024

int main() {
    WSADATA wsaData;
    SOCKET serverSocket, clientSocket;
    struct sockaddr_in serverAddr, clientAddr;
    int clientAddrSize = sizeof(clientAddr);
    char buffer[BUFFER_SIZE];
    int bytesReceived;

    // 初始化Winsock库
    if (WSAStartup(MAKEWORD(2, 2), &wsaData) != 0) {
        std::cerr << "WSAStartup failed." << std::endl;
        return 1;
    }

    // 创建套接字
    serverSocket = socket(AF_INET, SOCK_STREAM, 0);
    if (serverSocket == INVALID_SOCKET) {
        std::cerr << "socket failed: " << WSAGetLastError() << std::endl;
        WSACleanup();
        return 1;
    }

    // 设置服务器地址和端口
    serverAddr.sin_family = AF_INET;
    serverAddr.sin_addr.s_addr = inet_addr("127.0.0.1"); // 本地回环地址
    serverAddr.sin_port = htons(PORT);

    // 绑定套接字到指定的地址和端口
    if (bind(serverSocket, (struct sockaddr*)&serverAddr, sizeof(serverAddr)) == SOCKET_ERROR) {
        std::cerr << "bind failed: " << WSAGetLastError() << std::endl;
        closesocket(serverSocket);
        WSACleanup();
        return 1;
    }

    // 开始监听连接请求
    if (listen(serverSocket, SOMAXCONN) == SOCKET_ERROR) {
        std::cerr << "listen failed: " << WSAGetLastError() << std::endl;
        closesocket(serverSocket);
        WSACleanup();
        return 1;
    }

    std::cout << "Server is listening on port " << PORT << "..." << std::endl;

    // 接受连接请求
    clientSocket = accept(serverSocket, (struct sockaddr*)&clientAddr, &clientAddrSize);
    if (clientSocket == INVALID_SOCKET) {
        std::cerr << "accept failed: " << WSAGetLastError() << std::endl;
        closesocket(serverSocket);
        WSACleanup();
        return 1;
    }

    std::cout << "Client connected." << std::endl;

    // 接收数据
    bytesReceived = recv(clientSocket, buffer, BUFFER_SIZE, 0);
    if (bytesReceived == SOCKET_ERROR) {
        std::cerr << "recv failed: " << WSAGetLastError() << std::endl;
    } else if (bytesReceived == 0) {
        std::cout << "Client disconnected." << std::endl;
    } else {
        buffer[bytesReceived] = '\0'; // 确保字符串以空字符结尾
        std::cout << "Received: " << buffer << std::endl;

        // 发送数据
        const char* response = "Hello, client!";
        if (send(clientSocket, response, strlen(response), 0) == SOCKET_ERROR) {
            std::cerr << "send failed: " << WSAGetLastError() << std::endl;
        }
    }

    // 关闭套接字
    closesocket(clientSocket);
    closesocket(serverSocket);
    WSACleanup();

    return 0;
}

2.1.2 TCP客户端示例

#include <iostream>
#include <winsock2.h>
#pragma comment(lib, "Ws2_32.lib")

#define PORT 8080
#define BUFFER_SIZE 1024

int main() {
    WSADATA wsaData;
    SOCKET clientSocket;
    struct sockaddr_in serverAddr;
    char buffer[BUFFER_SIZE];
    int bytesSent, bytesReceived;

    // 初始化Winsock库
    if (WSAStartup(MAKEWORD(2, 2), &wsaData) != 0) {
        std::cerr << "WSAStartup failed." << std::endl;
        return 1;
    }

    // 创建套接字
    clientSocket = socket(AF_INET, SOCK_STREAM, 0);
    if (clientSocket == INVALID_SOCKET) {
        std::cerr << "socket failed: " << WSAGetLastError() << std::endl;
        WSACleanup();
        return 1;
    }

    // 设置服务器地址和端口
    serverAddr.sin_family = AF_INET;
    serverAddr.sin_addr.s_addr = inet_addr("127.0.0.1"); // 本地回环地址
    serverAddr.sin_port = htons(PORT);

    // 连接到服务器
    if (connect(clientSocket, (struct sockaddr*)&serverAddr, sizeof(serverAddr)) == SOCKET_ERROR) {
        std::cerr << "connect failed: " << WSAGetLastError() << std::endl;
        closesocket(clientSocket);
        WSACleanup();
        return 1;
    }

    std::cout << "Connected to server." << std::endl;

    // 发送数据
    const char* message = "Hello, server!";
    bytesSent = send(clientSocket, message, strlen(message), 0);
    if (bytesSent == SOCKET_ERROR) {
        std::cerr << "send failed: " << WSAGetLastError() << std::endl;
    } else {
        std::cout << "Sent: " << message << std::endl;
    }

    // 接收数据
    bytesReceived = recv(clientSocket, buffer, BUFFER_SIZE, 0);
    if (bytesReceived == SOCKET_ERROR) {
        std::cerr << "recv failed: " << WSAGetLastError() << std::endl;
    } else if (bytesReceived == 0) {
        std::cout<< "Connection closed by server." << std::endl;
	} else {
		buffer[bytesReceived] = '\0'; // 确保字符串以null结尾
		std::cout << "Received: " << buffer << std::endl;
	}

	// 关闭套接字并清理Winsock库
	closesocket(clientSocket);
	WSACleanup();

	return 0;

}

2.2 UDP协议示例

在C++中，进行UDP编程通常需要使用套接字（Socket）编程接口。以下是一个简单的UDP通信实例，包括服务器端和客户端的代码示例：

2.2.1 服务器端代码


#include <iostream>
#include <cstring>
#include <unistd.h>
#include <arpa/inet.h>
 
#define PORT 8888
#define BUFFER_SIZE 1024
 
int main() {
    int server_fd, new_socket;
    struct sockaddr_in address;
    int addrlen = sizeof(address);
    char buffer[BUFFER_SIZE] = {0};
    const char* message = "Hello from server";
 
    // 创建套接字
    if ((server_fd = socket(AF_INET, SOCK_DGRAM, 0)) == 0) {
        perror("socket failed");
        exit(EXIT_FAILURE);
    }
 
    // 绑定套接字
    address.sin_family = AF_INET;
    address.sin_addr.s_addr = INADDR_ANY;
    address.sin_port = htons(PORT);
    if (bind(server_fd, (struct sockaddr*)&address, sizeof(address)) < 0) {
        perror("bind failed");
        exit(EXIT_FAILURE);
    }
 
    while (true) {
        std::cout << "Waiting for message..." << std::endl;
        // 接收消息
        ssize_t len = recvfrom(server_fd, buffer, BUFFER_SIZE, 0, (struct sockaddr*)&address, (socklen_t*)&addrlen);
        if (len > 0) {
            std::cout << "Received message: " << std::string(buffer, len) << std::endl;
            // 处理消息
            std::string response = "Hello, client!";
            // 发送响应消息
            sendto(server_fd, response.c_str(), response.size(), 0, (struct sockaddr*)&address, addrlen);
        }
    }
 
    // 关闭套接字（在实际应用中，通常会有更复杂的资源管理逻辑）
    close(server_fd);
    return 0;

}

2.2.2 客户端代码


#include <iostream>
#include <cstring>
#include <unistd.h>
#include <arpa/inet.h>
 
#define PORT 8888
#define BUFFER_SIZE 1024
 
int main() {
    int sock;
    struct sockaddr_in server_addr;
    char buffer[BUFFER_SIZE] = {0};
    const char* message = "Hello, server!";
 
    // 创建套接字
    if ((sock = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
        perror("socket failed");
        exit(EXIT_FAILURE);
    }
 
    // 设置服务器地址
    server_addr.sin_family = AF_INET;
    server_addr.sin_port = htons(PORT);
    server_addr.sin_addr.s_addr = inet_addr("127.0.0.1"); // 本地回环地址
 
    // 发送消息
    sendto(sock, message, strlen(message), 0, (struct sockaddr*)&server_addr, sizeof(server_addr));
 
    // 接收响应消息
    ssize_t len = recvfrom(sock, buffer, BUFFER_SIZE, 0, NULL, NULL);
    if (len > 0) {
        std::cout << "Received response: " << std::string(buffer, len) << std::endl;
    }
 
    // 关闭套接字
    close(sock);
    return 0;

}

在这个示例中，服务器端创建了一个UDP套接字并绑定到指定的端口上，然后在一个无限循环中等待接收客户端发送的消息。接收到消息后，服务器处理消息并发送响应给客户端。客户端则创建一个UDP套接字，设置服务器地址，发送消息给服务器，并等待接收服务器的响应消息。

在C++网络编程中，错误处理与资源管理是两个至关重要的方面。正确的错误处理可以确保程序在遇到问题时能够优雅地处理，而不是崩溃或产生未定义行为。而有效的资源管理则可以防止内存泄漏、文件句柄泄漏等常见问题，从而保持系统的稳定性和性能。

三、网络编程中的错误处理和资源管理

3.1 错误处理

检查返回值：
许多网络编程函数都会返回一个值来表示操作是否成功。例如，socket(), bind(), connect(), send(), recv() 等函数都会返回特定的值或设置全局变量 errno 来指示错误。开发者需要仔细检查这些返回值，并根据需要进行适当的错误处理。
使用异常处理：
C++ 支持异常处理机制，可以使用 try-catch 块来捕获和处理异常。虽然标准的网络编程库（如 POSIX 套接字 API）通常不使用异常，但开发者可以封装这些 API，并在封装层中抛出异常来处理错误。
设置和检查 errno：
当系统调用失败时，通常会设置全局变量 errno 来指示错误的类型。开发者可以使用 perror() 或 strerror() 函数来打印或获取错误描述信息。
日志记录：
对于复杂的网络应用，记录详细的错误日志是非常有帮助的。这可以帮助开发者在问题发生时进行调试，并了解问题的上下文和发生频率。

3.2 资源管理

使用智能指针：
在 C++11 及更高版本中，智能指针（如 std::unique_ptr 和 std::shared_ptr）提供了自动管理动态分配内存的机制。这可以大大减少内存泄漏的风险。
RAII（Resource Acquisition Is Initialization）：
RAII 是一种管理资源的惯用法，它将资源的获取（如打开文件、创建套接字）与对象的构造函数绑定，将资源的释放与对象的析构函数绑定。这样，当对象超出作用域或被显式销毁时，资源会自动被释放。
显式关闭套接字和文件：
对于网络编程中的套接字和文件句柄，确保在不再需要时显式关闭它们是非常重要的。这可以通过在适当的代码位置调用 close() 函数来实现。
避免资源泄漏：
在处理网络请求时，可能会分配临时资源（如内存、缓冲区）。确保在请求处理完成后释放这些资源，以避免资源泄漏。
使用 std::array 或 std::vector 代替原始数组：
使用标准库中的容器类可以避免手动管理数组大小和内存分配的问题。这些容器类提供了自动的内存管理和边界检查。
线程同步：
在多线程环境中，确保对共享资源的访问是同步的，以避免数据竞争和未定义行为。可以使用互斥锁（如 std::mutex）、条件变量（如 std::condition_variable）等同步机制。
连接管理和超时处理：
在网络编程中，连接可能会因为各种原因而断开或变得不可用。因此，实现有效的连接管理和超时处理机制是非常重要的。这可以包括定期发送心跳包、检测连接状态、在超时后关闭连接等。

通过仔细的错误处理和资源管理，C++ 网络编程应用可以更加健壮、可靠和易于维护。这不仅可以提高应用的可用性，还可以减少潜在的安全漏洞和性能问题。