学懂C++（三十九）：网络编程——深入详解 TCP 和 UDP 的区别和应用场景

特性	TCP	UDP
连接类型	面向连接	无连接
可靠性	可靠	不可靠
数据传输顺序	保证按序传输	不保证按序传输
流控制	具有流控制机制	无流控制机制
拥塞控制	具有拥塞控制机制	无拥塞控制机制
头部开销	较大（20-60 字节）	较小（8 字节）
传输效率	较低（由于可靠性机制）	较高
适用场景	需要高可靠性的数据传输	需要高实时性的数据传输
应用示例	HTTP、FTP、SMTP、SSH	VoIP、视频会议、DNS、在线游戏

四、TCP 和 UDP 的工作原理

1. TCP 的工作原理

三次握手

三次握手用于建立 TCP 连接，确保双方都准备好进行数据传输：

SYN：客户端发送 SYN 报文，表示请求建立连接。
SYN-ACK：服务器收到 SYN 报文后，回应 SYN-ACK 报文，表示同意建立连接。
ACK：客户端收到 SYN-ACK 报文后，发送 ACK 报文，表示确认建立连接。

数据传输

TCP 通过序列号和确认应答机制，确保数据包按序到达和完整性：

序列号：每个数据包都有一个序列号，表示数据包在整个数据流中的位置。
确认应答 (ACK)：接收方发送 ACK 报文，确认收到的数据包。

四次挥手

四次挥手用于关闭 TCP 连接，确保双方都同意结束数据传输：

FIN：客户端发送 FIN 报文，表示请求关闭连接。
ACK：服务器收到 FIN 报文后，回应 ACK 报文，表示确认关闭请求。
FIN：服务器发送 FIN 报文，表示同意关闭连接。
ACK：客户端收到 FIN 报文后，发送 ACK 报文，表示确认关闭。

2. UDP 的工作原理

数据传输

UDP 直接将数据包发送到目标地址，无需建立连接和确认应答：

数据报：每个数据包称为数据报，包含源地址、目标地址、数据等信息。
无序传输：数据报可能乱序到达，应用程序需要自行处理数据的顺序性。

广播和多播

UDP 支持广播和多播，允许数据包同时发送到多个接收方：

广播：将数据包发送到同一网络中的所有主机。
多播：将数据包发送到特定的一组主机。

五、实例比较

以下是 TCP 和 UDP 的简单应用示例，展示它们的实际使用情况。

TCP 示例

TCP 服务器

#include <iostream>
#include <cstring>
#include <unistd.h>
#include <arpa/inet.h>

#define PORT 8080
#define BUFFER_SIZE 1024

int main() {
    int server_fd, new_socket;
    struct sockaddr_in address;
    int opt = 1;
    int addrlen = sizeof(address);
    char buffer[BUFFER_SIZE] = {0};
    const char* message = "Hello from server";

    // 创建套接字
    if ((server_fd = socket(AF_INET, SOCK_STREAM, 0)) == 0) {
        perror("socket failed");
        exit(EXIT_FAILURE);
    }

    // 绑定套接字
    if (setsockopt(server_fd, SOL_SOCKET, SO_REUSEADDR | SO_REUSEPORT, &opt, sizeof(opt))) {
        perror("setsockopt");
        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);
    }

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

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

    read(new_socket, buffer, BUFFER_SIZE);
    std::cout << "Message received: " << buffer << std::endl;

    send(new_socket, message, strlen(message), 0);
    std::cout << "Hello message sent" << std::endl;

    close(new_socket);
    close(server_fd);
    return 0;
}

TCP 客户端

#include <iostream>
#include <cstring>
#include <unistd.h>
#include <arpa/inet.h>

#define PORT 8080
#define BUFFER_SIZE 1024

int main() {
    int sock = 0;
    struct sockaddr_in serv_addr;
    char buffer[BUFFER_SIZE] = {0};
    const char* message = "Hello from client";

    // 创建套接字
    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(PORT);

    // 将服务器地址转为二进制形式
    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;
    }

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

    send(sock, message, strlen(message), 0);
    std::cout << "Hello message sent" << std::endl;

    read(sock, buffer, BUFFER_SIZE);
    std::cout << "Message received: " << buffer << std::endl;

    close(sock);
    return 0;
}

运行结果：

// 服务器端输出
Message received: Hello from client
Hello message sent

// 客户端输出
Hello message sent
Message received: Hello from server

UDP 示例

UDP 服务器

#include <iostream>
#include <cstring>
#include <unistd.h>
#include <arpa/inet.h>

#define PORT 8080
#define BUFFER_SIZE 1024

int main() {
    int sockfd;
    struct sockaddr_in server_addr, client_addr;
    char buffer[BUFFER_SIZE];
    const char* message = "Hello from server";

    // 创建套接字
    if ((sockfd = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
        perror("socket creation failed");
        exit(EXIT_FAILURE);
    }

    memset(&server_addr, 0, sizeof(server_addr));
    memset(&client_addr, 0, sizeof(client_addr));

    // 填充服务器信息
    server_addr.sin_family = AF_INET;
    server_addr.sin_addr.s_addr = INADDR_ANY;
    server_addr.sin_port = htons(PORT);

    // 绑定套接字
    if (bind(sockfd, (const struct sockaddr *)&server_addr, sizeof(server_addr)) < 0) {
        perror("bind failed");
        close(sockfd);
        exit(EXIT_FAILURE);
    }

    socklen_t len = sizeof(client_addr);
    int n = recvfrom(sockfd, (char *)buffer, BUFFER_SIZE, MSG_WAITALL, (struct sockaddr *)&client_addr, &len);
    buffer[n] = '\0';
    std::cout << "Message received: " << buffer << std::endl;

    sendto(sockfd, message, strlen(message), MSG_CONFIRM, (const struct sockaddr *) &client_addr, len);
    std::cout << "Hello message sent" << std::endl;

    close(sockfd);
    return 0;
}

UDP 客户端

#include <iostream>
#include <cstring>
#include <unistd.h>
#include <arpa/inet.h>

#define PORT 8080
#define BUFFER_SIZE 1024

int main() {
    int sockfd;
    struct sockaddr_in serv_addr;
    char buffer[BUFFER_SIZE];
    const char* message = "Hello from client";

    // 创建套接字
    if ((sockfd = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
        perror("socket creation failed");
        exit(EXIT_FAILURE);
    }

    memset(&serv_addr, 0, sizeof(serv_addr));

    // 填充服务器信息
    serv_addr.sin_family = AF_INET;
    serv_addr.sin_port = htons(PORT);
    serv_addr.sin_addr.s_addr = INADDR_ANY;

    sendto(sockfd, message, strlen(message), MSG_CONFIRM, (const struct sockaddr *) &serv_addr, sizeof(serv_addr));
    std::cout << "Hello message sent" << std::endl;

    socklen_t len = sizeof(serv_addr);
    int n = recvfrom(sockfd, (char *)buffer, BUFFER_SIZE, MSG_WAITALL, (struct sockaddr *) &serv_addr, &len);
    buffer[n] = '\0';
    std::cout << "Message received: " << buffer << std::endl;

    close(sockfd);
    return 0;
}

运行结果：

// 服务器端输出
Message received: Hello from client
Hello message sent

// 客户端输出
Hello message sent
Message received: Hello from server

六、总结

通过对 TCP 和 UDP 的深入解析，我们可以得出以下结论：

TCP 提供可靠的数据传输，适用于需要高可靠性和顺序保证的应用，如网页浏览、文件传输、电子邮件和远程登录。
UDP 提供不可靠但高效的数据传输，适用于对实时性要求高但容错性强的应用，如实时音视频传输、在线游戏、DNS 查询和广播多播应用。

在实际项目中，选择合适的传输协议至关重要，需要根据具体应用场景的需求来做出决策。希望本文的深入解析能够帮助读者更好地理解 TCP 和 UDP 的区别及其应用场景，提升网络编程能力。

猿享天开

关注

14
点赞
踩
9

收藏

觉得还不错? 一键收藏
0
评论
学懂C++（三十九）：网络编程——深入详解 TCP 和 UDP 的区别和应用场景

TCP 和 UDP 的区别及其应用场景详解
复制链接

扫一扫

专栏目录