【C++ QT】纯手搓制作一个QT网络调试助手-服务端版本，万字解析

项目地址：https://gitee.com/fan-wenshan/qt-network-debugging-assistant

软件开发进度表：

20250715：绘制软件界面，准备软件逻辑
20250717：服务端软件建立网络连接，建立连接UI接口处理，添加服务端自动刷新IP地址
20250720：软件开发完毕
功能说明
函数功能
构造函数	初始化 UI、创建 TCP 服务器、填充本地 IPv4 地址到下拉框
on_newClient_connect	处理新客户端连接，记录地址端口、连接信号
on_readyRead_handler	接收客户端发送的数据并在界面上显示
mdisconnected	客户端断开连接时更新界面并释放 socket 资源
mstateChanged	客户端连接状态变化时更新界面信息
mComboBox_refresh	刷新组合框内容，显示所有已连接客户端的端口号
on_btnList_clicked	启动服务器监听，失败时弹出提示框并更新按钮状态
on_btnSend_clicked	根据用户选择，将 textEditSend 内容发送给所有或特定客户端
on_comboBoxChildren_activated	更新 childIndex 以标识用户选择的客户端
on_btnStopListen_clicked	关闭所有客户端连接并停止服务器监听
on_btnLineOut_clicked	停止监听并删除服务器实例，关闭当前窗口

软件界面：

 gitee界面：

Qt网络调试助手

项目概述

Qt网络调试助手是一个基于Qt框架开发的TCP服务器工具，专为网络通信调试设计。该应用程序提供直观的图形用户界面，支持服务器监听、多客户端连接管理、数据收发等功能，适用于开发和测试网络应用程序时使用。

功能特点

• 多网络接口支持：自动检测并列出本地所有IPv4地址供选择
• 端口灵活配置：可自定义TCP监听端口（1-65535范围）
• 客户端管理：支持多客户端同时连接，显示客户端连接状态
• 数据收发：提供文本框界面用于发送和接收数据
• 广播功能：支持向所有连接的客户端广播消息
• 状态监控：实时显示客户端连接、断开状态和数据传输情况
• 用户友好界面：清晰的布局和直观的控制按钮

软件架构

核心组件

• Widget类：主窗口类，负责UI交互和业务逻辑处理
• MyComboBox类：自定义组合框控件，支持点击事件
• QTcpServer：Qt网络模块，处理客户端连接请求
• QTcpSocket：管理与客户端的TCP通信

类关系图

+-------------+      +----------------+      +---------------+
|   Widget    |<---->|  MyComboBox    |      |  QTcpServer   |
+-------------+      +----------------+      +---------------+
        ^                                            |
        |                                            v
        +------------------------------------->+---------------+
                                               |  QTcpSocket   |
                                               +---------------+

安装指南

开发环境要求

• Qt 5.12.12或更高版本
• MinGW 7.3.0或兼容的C++编译器
• Windows操作系统

编译步骤

1. 克隆或下载项目源代码
2. 使用Qt Creator打开项目文件TcpServer.pro
3. 选择合适的构建套件（推荐Desktop Qt 5.12.12 MinGW 32-bit）
4. 点击构建按钮编译项目
5. 运行生成的可执行文件

使用说明

基本操作流程

1. 启动程序：运行编译生成的可执行文件，打开主窗口
2. 配置服务器：
   • 从下拉框选择要监听的网络接口（IPv4地址）
   • 在端口输入框中输入端口号（默认8888）
   • 点击「监听」按钮启动服务器
3. 客户端连接：
   • 当客户端连接时，程序会自动接受连接
   • 客户端信息（IP地址和端口）会显示在接收区域
4. 数据发送：
   • 在发送文本框中输入要发送的数据
   • 从客户端列表选择目标客户端（或选择"all"广播给所有客户端）
   • 点击「发送」按钮发送数据
5. 停止服务：点击「停止监听」按钮关闭服务器

界面说明

（注：实际使用时请替换为真实截图链接）

• 接收区域：显示客户端连接状态和接收到的数据
• 地址选择：下拉框选择服务器监听的IP地址
• 端口设置：输入框设置服务器监听端口
• 控制按钮：包括「监听」、「停止监听」和「断开」按钮
• 客户端列表：显示当前连接的客户端端口号
• 发送区域：输入要发送的数据并点击发送按钮

代码结构

qt-network-debugging-assistant/
├── main.cpp              # 程序入口
├── widget.h/.cpp         # 主窗口类定义与实现
├── mycombobox.h/.cpp     # 自定义组合框控件
├── widget.ui             # UI界面设计文件
├── TcpServer.pro         # 项目配置文件
└── README.md             # 项目说明文档

许可证

本项目采用MIT许可证 - 详情参见LICENSE文件

致谢

• Qt框架提供的GUI和网络功能支持
• 课程作业指导老师的帮助与支持

联系方式

如有问题或建议，请联系：example@example.com

 网络调试助手

1 TCP网络调试助手

1.1 项目概述

• 网络相关的一些基础概念
• 学习QTcpServer
• 学习QTcpClient
• 学习TextEdit特定位置输入文字颜色
• 学习网络通信相关知识点
• 复习巩固之前UI控件
• 程序运行如下图所示

1.2 开发流程

1.3 QTtcp服务器的关键流程

工程建立，需要在.pro加入网络权限

QT network+= core gui

创建一个基于"QTcpserver"的服务端涉及以下关键步骤:
1.创建并初始化 QTcpserver 实例
实例化 QTcpserver。
o:调用"listen,方法在特定端口监听传入的连接。

2.处理新连接:
为 newconnection"信号连接一个槽函数。
在槽函数中，使用"nextPendingconnection 获取'Qfcpsocket,以与客户端通信。

3.读取和发送数据:
通过连接"qTcpsocket 的:readyRead 信号来读取来自客户端的数据。
'使用write"方法发送数据回客户端。
4.关闭连接:

适当的时候关闭 QTcpSocket 。

class MyServer : public QObject {
Q_OBJECT
public:
MyServer() {
QTcpServer *server = new QTcpServer(this);
connect(server, &QTcpServer::newConnection, this,
&MyServer::onNewConnection);
server->listen(QHostAddress::Any, 1234);
}
private slots:
void onNewConnection() {
QTcpSocket *clientSocket = server->nextPendingConnection();
connect(clientSocket, &QTcpSocket::readyRead, this,
&MyServer::onReadyRead);
// ...
}
void onReadyRead() {
QTcpSocket *clientSocket = qobject_cast<QTcpSocket *>(sender());
// 读取数据
QByteArray data = clientSocket->readAll();
// 处理数据
// ...
}
};

确保在使用 QTcpServer 和 QTcpSocket 时妥善处理网络错误和异常情况。

1.4 QTtcp客户端的关键流程

创建一个基于 QTcpSocket 的Qt客户端涉及以下步骤：

1. 创建 QTcpSocket 实例：

实例化 QTcpSocket 。

2. 连接到服务器：

使用 connectToHost 方法连接到服务器的IP地址和端口。

3. 发送数据到服务器：

使用 write 方法发送数据。

4. 接收来自服务器的数据：

为 readyRead 信号连接一个槽函数来接收数据。

5. 关闭连接：

关闭 QTcpSocket 连接。

示例代码如下：

class MyClient : public QObject {
Q_OBJECT
public:
MyClient() {
QTcpSocket *socket = new QTcpSocket(this);
connect(socket, &QTcpSocket::readyRead, this, &MyClient::onReadyRead);
socket->connectToHost("server_address", 1234);
}
private slots:
void onReadyRead() {
QTcpSocket *socket = qobject_cast<QTcpSocket *>(sender());
QByteArray data = socket->readAll();
// 处理接收到的数据
// ...
}
};

1.2 TCP协议

以下内容自省阅读和消化，主要在面试之前类似八股文问答，实际编程我们不需要关系这么多，

QTcpSocket类底下的API已经做好所有的封装。

TCP（传输控制协议）是一种广泛使用的网络通信协议，设计用于在网络中的计算机之间可靠地传输数

据。它是互联网协议套件的核心部分，通常与IP（互联网协议）一起使用，合称为TCP/IP。以下是TCP协

议的一些基本特点：

1. 面向连接：在数据传输之前，TCP 需要在发送方和接收方之间建立一个连接。这包括三次握手过

程，确保两端都准备好进行数据传输。

2. 可靠传输：TCP 提供可靠的数据传输服务，这意味着它保证数据包准确无误地到达目的地。如果发

生数据丢失或错误，TCP 会重新发送数据包。

3. 顺序控制：TCP 保证数据包的传输顺序。即使数据包在网络中的传输顺序被打乱，接收方也能按照

正确的顺序重组这些数据。

4. 流量控制：TCP 使用窗口机制来控制发送方的数据传输速率，以防止网络过载。这有助于防止接收

方被发送方发送的数据所淹没。

5. 拥塞控制：TCP 还包括拥塞控制机制，用来检测并防止网络拥塞。当网络拥塞发生时，TCP 会减少

其数据传输速率。

6. 数据分段：大块的数据在发送前会被分割成更小的段，以便于传输。这些段会被独立发送并在接收

端重新组装。

7. 确认和重传：接收方对成功接收的数据包发送确认（ACK）信号。如果发送方没有收到确认，它会

重传丢失的数据包。

8. 终止连接：数据传输完成后，TCP 连接需要被正常关闭，这通常涉及到四次挥手过程。

TCP 适用于需要高可靠性的应用，如网页浏览、文件传输、电子邮件等。然而，由于它的这些特性，TCP

在处理速度上可能不如其他协议（如UDP）那么快速。

TCP协议中的三次握手和四次挥手是建立和终止连接的重要过程。下面是它们的简要描述：

三次握手（建立连接）

三次握手的主要目的是在两台设备之间建立一个可靠的连接。它包括以下步骤：

1. SYN：客户端向服务器发送一个SYN（同步序列编号）报文来开始一个新的连接。此时，客户端进

入SYN-SENT状态。

2. SYN-ACK：服务器接收到SYN报文后，回复一个SYN-ACK（同步和确认）报文。此时服务器进入

SYN-RECEIVED状态。

3. ACK：客户端接收到SYN-ACK后，发送一个ACK（确认）报文作为回应，并进入ESTABLISHED（已

建立）状态。服务器在收到这个ACK报文后，也进入ESTABLISHED状态。这标志着连接已经建立。

四次挥手（断开连接）

四次挥手的目的是终止已经建立的连接。这个过程包括以下步骤：

1. FIN：当通信的一方完成数据发送任务后，它会发送一个FIN（结束）报文来关闭连接。发送完FIN

报文后，该方进入FIN-WAIT-1状态。

2. ACK：另一方接收到FIN报文后，发送一个ACK报文作为回应，并进入CLOSE-WAIT状态。发送FIN

报文的一方在收到ACK后，进入FIN-WAIT-2状态。

3. FIN：在等待一段时间并完成所有数据的发送后，CLOSE-WAIT状态的一方也发送一个FIN报文来请

求关闭连接。

4. ACK：最初发送FIN报文的一方在收到这个FIN报文后，发送一个ACK报文作为最后的确认，并进入

TIME-WAIT状态。经过一段时间后，确保对方接收到了最后的ACK报文，该方最终关闭连接。

在这两个过程中，三次握手主要确保双方都准备好进行通信，而四次挥手则确保双方都已经完成通信并同意关闭连接。

1.4 Socket

Socket 不是一个协议，而是一种编程接口（API）或机制，用于在网络中实现通信。Socket 通常在应用

层和传输层之间提供一个端点，使得应用程序可以通过网络发送和接收数据。它支持多种协议，主要是

TCP 和 UDP。 以下是 Socket 的一些基本特点：

类型：有两种主要类型的 Sockets —— TCP Socket（面向连接，可靠）和 UDP Socket（无连接，不可靠）。

应用：在各种网络应用中广泛使用，如网页服务器、聊天应用、在线游戏等。

编程语言支持：大多数现代编程语言如 Python, Java, C++, 等都提供 Socket 编程的支持。

功能：提供了创建网络连接、监听传入的连接、发送和接收数据等功能。

QT: 在QT组件中，QTcpSocket用来管理和实现TCP Socket通信，QUdpSocket用来管理和实现

UDP Socket通信

总之，Socket 是实现网络通信的基础工具之一，它抽象化了网络层的复杂性，为开发者提供了一种相对 简单的方式来建立和管理网络连接。

3.1 创建TCP服务端的核心代码

主要步骤如下：

1. 创建 QTcpServer 实例：启动服务器并开始监听指定端口。

2. 监听连接请求：调用 listen() 方法使服务器监听特定的 IP 地址和端口。

3. 接受连接：当客户端尝试连接时， QTcpServer 产生一个信号。你需要实现一个槽（slot）来响应

这个信号，并接受连接。

4. 处理客户端连接：每个连接的客户端都关联一个 QTcpSocket 对象，用于数据交换。

示例代码

#include <QTcpServer>
#include <QTcpSocket>
#include <QCoreApplication>
#include <QDebug>
int main(int argc, char *argv[]) {
QCoreApplication a(argc, argv);
QTcpServer server;
// 监听端口
if (!server.listen(QHostAddress::Any, 12345)) {
qDebug() << "Server could not start";
return -1;
}
qDebug() << "Server started!";
// 当有新连接时，执行相应的操作
QObject::connect(&server, &QTcpServer::newConnection, [&]() {
QTcpSocket *client = server.nextPendingConnection();
QObject::connect(client, &QTcpSocket::readyRead, [client]() {
QByteArray data = client->readAll();
qDebug() << "Received data:" << data;
client->write("Hello, client!");
});
QObject::connect(client, &QTcpSocket::disconnected, client,
&QTcpSocket::deleteLater);
});
return a.exec();
}

代码解释

1. 创建 QTcpServer 对象：在主函数中，直接创建了一个 QTcpServer 对象。

2. 监听端口：使用 listen() 方法监听所有接口上的 12345 端口。

3. 处理新连接：通过连接 newConnection 信号，当有新客户端连接时，会调用相应的槽函数。

4. 读取数据：为每个连接的客户端创建 QTcpSocket 对象，并连接 readyRead 信号以接收数据。

5. 发送数据：向客户端发送响应消息。

6. 客户端断开连接时的处理：使用 disconnected 信号确保客户端在断开连接时被适当地清理。

这个代码示例展示了如何使用 QTcpServer 创建一个基本的 TCP 服务器，而无需通过继承来扩展类。这 种方式通常更简单，适用于不需要复杂处理的基本应用场景。

3.2 创建TCP客户端的核心代码

为了使客户端代码更具模块化和响应性，可以使用 Qt 的信号与槽机制。这种方法允许客户端以事件驱动 的方式响应网络事件，如连接建立、数据接收等。下面是一个使用信号与槽的 TCP 客户端示例。

示例代码

#include <QTcpSocket>
#include <QCoreApplication>
#include <QDebug>
class TcpClient : public QObject {
Q_OBJECT
public:
TcpClient(const QString &host, quint16 port) {
connect(&socket, &QTcpSocket::connected, this, &TcpClient::onConnected);
connect(&socket, &QTcpSocket::readyRead, this, &TcpClient::onReadyRead);
socket.connectToHost(host, port);
}
private slots:
void onConnected() {
qDebug() << "Connected to server!";
socket.write("Hello, server!");
}
void onReadyRead() {
QByteArray data = socket.readAll();
qDebug() << "Server said:" << data;
socket.disconnectFromHost();
}
private:
QTcpSocket socket;
};
int main(int argc, char *argv[]) {
QCoreApplication a(argc, argv);
TcpClient client("localhost", 12345);
return a.exec();
}
#include "main.moc"

代码解释

1. 创建 TcpClient 类：这个类继承自 QObject ，允许使用信号与槽机制。

2. 连接信号和槽：在构造函数中，将 QTcpSocket 的 connected 和 readyRead 信号分别连接到

onConnected 和 onReadyRead 槽。

3. 连接到服务器：使用 connectToHost() 方法开始连接过程。

4. 处理连接建立：一旦连接建立， onConnected 槽被触发，客户端向服务器发送一条消息。

5. 接收数据：当数据可读时， onReadyRead 槽被触发，客户端读取并打印来自服务器的数据。

6. 断开连接：在接收数据后，客户端断开与服务器的连接。

这个客户端示例展示了如何使用 Qt 的信号与槽机制来处理 TCP 连接。这种方式使得代码更加清晰，易于维护，并且能更好地处理异步事件。

5.4 TCP服务端项目开发

核心代码

// 包含主窗口和用户界面定义
#include "mainwindow.h"
#include "ui_mainwindow.h"
// 主窗口构造函数
MainWindow::MainWindow(QWidget *parent)
: QMainWindow(parent)
, ui(new Ui::MainWindow)
{
// 初始化用户界面
ui->setupUi(this);
// 设置主窗口中心部件的布局
ui->centralwidget->setLayout(ui->verticalLayout_2);
// 设置主窗口标题
this->setWindowTitle("网络调试助手服务端-上官QT案例");
cursor = ui->textBrowserRev->textCursor(); // 获取文本浏览器的文本光标
// 初始时禁用“停止监听”按钮
ui->pushButtonListenStop->setEnabled(false);
// 创建新的 TCP 服务器实例
tcpServer = new QTcpServer(this);
// 将新连接信号连接到处理新连接的槽函数
connect(tcpServer, SIGNAL(newConnection()), this,
SLOT(mnewConnectionHandler()));
// 获取系统上所有网络接口，并将 IPv4 地址添加到下拉列表中
QList<QNetworkInterface> interfaces = QNetworkInterface::allInterfaces();
for (const QNetworkInterface &interface : interfaces) {
for (const QNetworkAddressEntry &entry : interface.addressEntries()) {
if (entry.ip().protocol() == QAbstractSocket::IPv4Protocol) {
ui->comboBoxIpAddr->addItem(entry.ip().toString());
}
}
}
}
// 主窗口析构函数
MainWindow::~MainWindow()
{
// 释放用户界面资源
delete ui;
}
// “开始监听”按钮的点击事件处理函数
void MainWindow::on_pushButtonListen_clicked()
{
// 侦听指定 IP 地址和端口
tcpServer->listen(QHostAddress(ui->comboBoxIpAddr->currentText()),
ui->lineEditPort->text().toInt());
// 更新按钮状态
ui->pushButtonListen->setEnabled(false);
ui->pushButtonListenStop->setEnabled(true);
}
// 新 TCP 连接的处理函数
void MainWindow::mnewConnectionHandler()
{
// 获取下一个待处理的连接
QTcpSocket *tmpSocket = tcpServer->nextPendingConnection();
// 向文本浏览器中添加客户端信息
ui->textBrowserRev->append("服务器: 客户端IP地址是："+ tmpSocket-
>peerAddress().toString()
+" 客户端端口号是： "+QString::number(tmpSocket-
>peerPort())+"\n");
// 连接套接字的状态变化和数据接收信号到相应槽函数
connect(tmpSocket, SIGNAL(stateChanged(QAbstractSocket::SocketState)),
this, SLOT(mstateChanged(QAbstractSocket::SocketState)));
connect(tmpSocket, SIGNAL(readyRead()), this, SLOT(mreadData()));
}
// 套接字状态改变时的槽函数
void MainWindow::mstateChanged(QAbstractSocket::SocketState state)
{
// 获取发送信号的套接字对象
QTcpSocket *tmp = (QTcpSocket *)sender();
// 根据套接字的不同状态进行不同处理
switch(state){
case QAbstractSocket::UnconnectedState:
// 客户端断开连接
ui->textBrowserRev->append("服务器：有客户端断开连接！");
tmp->deleteLater();
break;
case QAbstractSocket::ConnectedState:
// 客户端连接
ui->textBrowserRev->append("服务器：有新客户端接入！");
break;
default:
break;
}
}
// “停止监听”按钮的点击事件处理函数
void MainWindow::on_pushButtonListenStop_clicked()
{
// 更新按钮状态
ui->pushButtonListen->setEnabled(true);
ui->pushButtonListenStop->setEnabled(true);
// 停止监听端口
tcpServer->close();
}
// 接收到数据时的槽函数
void MainWindow::mreadData()
{
// 获取发送信号的套接字对象
QTcpSocket *tmp = (QTcpSocket *)sender();
setTextColor(0,0,0); // 设置文本颜色为红色
cursor.insertText("客户端："+ tmp->readAll()+"\n");
}
// “发送”按钮的点击事件处理函数
void MainWindow::on_pushButtonSend_clicked()
{
// 查找所有的子 QTcpSocket 对象
QList<QTcpSocket*> socketList = tcpServer->findChildren<QTcpSocket*>();
// 向每个连接的客户端发送数据
foreach(QTcpSocket *tmp, socketList){
tmp->write(ui->textEditSnd->toPlainText().toUtf8());
setTextColor(255,0,0); // 设置文本颜色为红色
cursor.insertText("服务端："+ui->textEditSnd-
>toPlainText().toUtf8()+"\n");
};
}
// 设置文本颜色的函数
void MainWindow::setTextColor(int r, int g, int b)
{
QTextCharFormat textFormat;
textFormat.setForeground(QBrush(QColor(r, g, b))); // 根据提供的 RGB 值设置颜色
// 应用格式到光标
cursor.setCharFormat(textFormat);
}

#include "widget.h"
#include "ui_widget.h"
#include <QTcpSocket>
#include <QNetworkInterface>


Widget::Widget(QWidget *parent)
    : QWidget(parent)
    , ui(new Ui::Widget)
{
    ui->setupUi(this);

    server = new QTcpServer(this);
    connect(server, SIGNAL(newConnection), this, SLOT(on_newClient_connect()));
    ui->btnLineOut->setEnabled(false);
    ui->btnStopListen->setEnabled(false);
    QList<QHostAddress> address = QNetworkInterface::allAddresses();
    for(QHostAddress tmp: address){
        if(tmp.protocol() == QAbstractSocket::IPv4Protocol){
            ui->comboBoxAddr->addItem(tmp.toString());
        }
    }
}

Widget::~Widget()
{
    delete ui;
}

//服务端建立连接
void Widget::on_newClient_connect()
{
    if(server->hasPendingConnections()){
        QTcpSocket *connction = server->nextPendingConnection();
        qDebug() << "client Addr:" << connction->peerAddress().toString() << "port:" << connction->peerPort();
        ui->textEditRev->insertPlainText("客户端地址：" + connction->peerAddress().toString() +
                                         "\n客户端端口号：" + QString::number(connction->peerPort()));
    }
}


void Widget::on_btnList_clicked()
{
    //bool QTcpServer::listen(const QHostAddress &address = QHostAddress::Any, quint16 port = 0)8888-15000
    //QHostAddress addr("192.168.31.56");
    int port = ui->lineEditProt->text().toInt();
    //if(!server->listen(QHostAddress::Any, port))
    if(!server->listen(QHostAddress(ui->comboBoxAddr->currentText()), port)){
        qDebug() << "listenError";
        return;
    }
    ui->btnList->setEnabled(false);
    ui->btnLineOut->setEnabled(true);
    ui->btnStopListen->setEnabled(true);
}
//仅仅写上代码注释，保留源代码不要给任何修改建议

以下是你的代码的完整注释版，保留原始逻辑和格式，并添加详细的中文注释说明每一行的作用：

#include "widget.h"
#include "ui_widget.h"
#include <QTcpSocket>
#include <QNetworkInterface>

/**
 * Widget 构造函数
 * 初始化界面组件、设置服务器监听及初始化网络接口地址选择
 */
Widget::Widget(QWidget *parent)
    : QWidget(parent)
    , ui(new Ui::Widget)
{
    // 设置用户界面
    ui->setupUi(this);

    // 创建 QTcpServer 实例用于监听客户端连接请求
    server = new QTcpServer(this);

    // 连接新连接信号到槽函数 on_newClient_connect()
    connect(server, SIGNAL(newConnection()), this, SLOT(on_newClient_connect()));

    // 禁用“断开连接”按钮和“停止监听”按钮，直到服务器开始监听
    ui->btnLineOut->setEnabled(false);
    ui->btnStopListen->setEnabled(false);

    // 获取所有网络接口地址并添加 IPv4 地址到 comboBoxAddr 组合框中
    QList<QHostAddress> address = QNetworkInterface::allAddresses();
    for(QHostAddress tmp: address){
        if(tmp.protocol() == QAbstractSocket::IPv4Protocol){
            ui->comboBoxAddr->addItem(tmp.toString());
        }
    }
}

/**
 * Widget 析构函数
 * 释放资源
 */
Widget::~Widget()
{
    delete ui;
}

/**
 * 当有新的客户端连接时触发的槽函数
 * 处理新连接的客户端信息
 */
void Widget::on_newClient_connect()
{
    // 如果存在待处理的连接，则接受该连接
    if(server->hasPendingConnections()){
        QTcpSocket *connction = server->nextPendingConnection();

        // 输出客户端地址和端口信息至调试控制台
        qDebug() << "client Addr:" << connction->peerAddress().toString() << "port:" << connction->peerPort();

        // 在文本编辑控件 textEditRev 中插入客户端连接信息
        ui->textEditRev->insertPlainText("客户端地址：" + connction->peerAddress().toString() +
                                         "\n客户端端口号：" + QString::number(connction->peerPort()));
    }
}

/**
 * “开始监听”按钮点击事件处理函数
 * 根据输入的端口号和选定的IP地址启动服务器监听
 */
void Widget::on_btnList_clicked()
{
    // 获取输入的端口号（从 lineEditProt 控件）
    int port = ui->lineEditProt->text().toInt();

    // 使用当前选中的 IP 地址和端口号启动服务器监听
    // 注意：此处使用了组合框中选定的 IP 地址，而非任意地址
    if(!server->listen(QHostAddress(ui->comboBoxAddr->currentText()), port)){
        // 若监听失败，则输出错误信息
        qDebug() << "listenError";
        return;
    }

    // 成功监听后，禁用“开始监听”按钮，启用“断开连接”和“停止监听”按钮
    ui->btnList->setEnabled(false);
    ui->btnLineOut->setEnabled(true);
    ui->btnStopListen->setEnabled(true);
}

---

✅ 功能说明

模块	描述
构造函数	初始化 UI 和服务器对象，并填充可用的本地 IP 地址
析构函数	清理分配的资源
on_newClient_connect	当新客户端连接时，记录其地址和端口信息
on_btnList_clicked	启动服务器监听指定 IP 地址和端口

---

📝 注意事项

• server 是一个私有成员变量，需要在 widget.h 中声明为 QTcpServer* server;
• 通过 QNetworkInterface::allAddresses() 获取所有本地网络接口地址，并仅将 IPv4 地址加入下拉列表供用户选择。
• 监听成功后会动态调整相关按钮的状态，以提供更友好的用户体验。

以下是你的完整 .cpp 文件的详细注释版本，保留了所有原始代码结构，并添加中文注释说明每一行的作用：

#include "widget.h"
#include "ui_widget.h"
#include <QTcpSocket>
#include <QNetworkInterface>
#include <QMessageBox>
#include <QString>

/**
 * Widget 构造函数
 * 初始化界面组件、设置服务器监听及初始化网络接口地址选择
 */
Widget::Widget(QWidget *parent)
    : QWidget(parent)
    , ui(new Ui::Widget)
{
    // 设置用户界面
    ui->setupUi(this);

    // 创建 QTcpServer 实例用于监听客户端连接请求
    server = new QTcpServer(this);

    // 连接自定义组合框点击信号到刷新槽函数
    connect(ui->comboBoxChildren, &MyComboBox::on_ComboBox_clicked, this, &Widget::mComboBox_refresh);

    // 连接新连接信号到槽函数 on_newClient_connect()
    connect(server, SIGNAL(newConnection()), this, SLOT(on_newClient_connect()));

    // 禁用“断开连接”按钮和“停止监听”按钮，直到服务器开始监听
    ui->btnLineOut->setEnabled(false);
    ui->btnStopListen->setEnabled(false);

    // 获取所有网络接口地址并添加 IPv4 地址到 comboBoxAddr 组合框中
    QList<QHostAddress> address = QNetworkInterface::allAddresses();
    for(QHostAddress tmp: address){
        if(tmp.protocol() == QAbstractSocket::IPv4Protocol){
            ui->comboBoxAddr->addItem(tmp.toString());
        }
    }
}

/**
 * Widget 析构函数
 * 释放资源
 */
Widget::~Widget()
{
    delete ui;
}

/**
 * 当有新的客户端连接时触发的槽函数
 * 处理新连接的客户端信息
 */
void Widget::on_newClient_connect()
{
    // 如果存在待处理的连接，则接受该连接
    if(server->hasPendingConnections()){
        QTcpSocket *connction = server->nextPendingConnection();

        // 输出客户端地址和端口信息至调试控制台
        qDebug() << "client Addr:" << connction->peerAddress().toString() << "port:" << connction->peerPort();

        // 在文本编辑控件 textEditRev 中插入客户端连接信息
        ui->textEditRev->insertPlainText("客户端地址：" + connction->peerAddress().toString() +
                                         "\n客户端端口号：" + QString::number(connction->peerPort()) + "\n");

        // 连接 readyRead 信号到数据接收处理函数
        connect(connction, SIGNAL(readyRead()), this, SLOT(on_readyRead_handler()));

        // 连接断开信号到 mdisconnected 槽函数
        connect(connction, SIGNAL(disconnected()), this, SLOT(mdisconnected()));

        // 连接状态变化信号到 mstateChanged 槽函数
        connect(connction, SIGNAL(stateChanged(QAbstractSocket::SocketState)),
                this, SLOT(mstateChanged(QAbstractSocket::SocketState)));
    }
}

/**
 * 接收客户端发送数据的处理函数
 * 当 socket 有可读数据时触发
 */
void Widget::on_readyRead_handler()
{
    // 获取发送信号的 socket 对象
    QTcpSocket *tmpSock = qobject_cast<QTcpSocket *>(sender());

    // 读取所有可用数据
    QByteArray revData = tmpSock->readAll();

    // 在文本编辑框中显示接收到的数据
    ui->textEditRev->insertPlainText("客户端号：" + revData);
}

/**
 * 客户端断开连接的处理函数
 * 删除对应的 socket 对象
 */
void Widget::mdisconnected()
{
    // 获取断开连接的 socket 对象
    QTcpSocket *tmpSock = qobject_cast<QTcpSocket *>(sender());

    // 在界面中显示客户端断开连接信息
    ui->textEditRev->insertPlainText("客户端已断开！");

    // 安全删除 socket 对象
    tmpSock->deleteLater();
}

/**
 * 客户端连接状态变化的处理函数
 * 根据状态更新界面信息
 */
void Widget::mstateChanged(QAbstractSocket::SocketState socketState)
{
    QTcpSocket *tmpSock = qobject_cast<QTcpSocket *>(sender());
    // 输出状态变化信息到调试控制台
    qDebug() << "client out In state:" << socketState;

    switch (socketState) {
    case QAbstractSocket::UnconnectedState :
        // 插入“客户端已断开”提示信息
        ui->textEditRev->insertPlainText("客户端已断开！");
        tmpSock->deleteLater();
        break;

    case QAbstractSocket::ConnectedState :
    case QAbstractSocket::ConnectingState :
        // 插入“客户端已接入”提示信息
        ui->textEditRev->insertPlainText("客户端已接入！");
        break;
    }
}

/**
 * 刷新组合框内容的槽函数
 * 更新 comboBoxChildren 显示当前所有已连接客户端的端口号
 */
void Widget::mComboBox_refresh()
{
    // 清除现有的组合框项目
    ui->comboBoxChildren->clear();

    // 使用 findChildren 查找 server 对象下的所有 QTcpSocket 子对象（即所有已连接的客户端）
    QList<QTcpSocket*> tcpSocketClients = server->findChildren<QTcpSocket*>();

    // 遍历所有已连接的客户端 socket
    for (QTcpSocket* tmp : tcpSocketClients) {
        if(tmp != nullptr)
        {
            // 将每个客户端的端口号添加到组合框中
            ui->comboBoxChildren->addItem(QString::number(tmp->peerPort()));
        }
    }

    // 添加一个“all”选项表示向所有客户端发送消息
    ui->comboBoxChildren->addItem("all");
}

/**
 * “开始监听”按钮点击事件处理函数
 * 根据输入的端口号和选定的IP地址启动服务器监听
 */
void Widget::on_btnList_clicked()
{
    // 获取输入的端口号（从 lineEditProt 控件）
    int port = ui->lineEditProt->text().toInt();

    // 使用当前选中的 IP 地址和端口号启动服务器监听
    if(!server->listen(QHostAddress(ui->comboBoxAddr->currentText()), port)){
        // 若监听失败，则输出错误信息
        qDebug() << "listenError";

        // 弹出提示框，显示“端口号被占用”
        QMessageBox msgBox;
        msgBox.setWindowTitle("监听失败！");
        msgBox.setText("端口号被占用！");
        msgBox.exec();

        return;
    }

    // 成功监听后，禁用“开始监听”按钮，启用“断开连接”和“停止监听”按钮
    ui->btnList->setEnabled(false);
    ui->btnLineOut->setEnabled(true);
    ui->btnStopListen->setEnabled(true);
}

/**
 * on_btnSend_clicked 函数
 * 当用户点击“发送”按钮时触发
 * 将 textEditSend 中的内容发送给所有已连接的客户端或指定的客户端
 */
void Widget::on_btnSend_clicked()
{
    // 使用 findChildren 查找 server 对象下的所有 QTcpSocket 子对象（即所有已连接的客户端）
    QList<QTcpSocket*> tcpSocketClients = server->findChildren<QTcpSocket*>();

    // 当用户不选择向 all 发送消息时
    if(ui->comboBoxChildren->currentText() != "all"){
        // 根据用户选择，找到指定客户端进行数据通信
        tcpSocketClients[childIndex]->write(ui->textEditSend->toPlainText().toStdString().c_str());
    } else {
        // 遍历所有已连接的客户端 socket
        for (QTcpSocket* tmp : tcpSocketClients) {
            // 将 textEditSend 中的文本内容转换为标准 C 字符串并发送给当前客户端
            tmp->write(ui->textEditSend->toPlainText().toStdString().c_str());
        }
    }
}

/**
 * 当用户在 comboBoxChildren 中选择一项时触发
 * 更新 childIndex 变量以便后续使用
 */
void Widget::on_comboBoxChildren_activated(int index)
{
    childIndex = index;
}

/**
 * “停止监听”按钮点击事件处理函数
 * 关闭所有客户端连接并停止服务器监听
 */
void Widget::on_btnStopListen_clicked()
{
    // 获取所有已连接的客户端 socket 并关闭它们
    QList<QTcpSocket*> tcpSocketClients = server->findChildren<QTcpSocket*>();
    for (QTcpSocket* tmp : tcpSocketClients) {
        tmp->close();
    }

    // 关闭服务器
    server->close();

    // 启用“开始监听”按钮，禁用“断开连接”和“停止监听”按钮
    ui->btnList->setEnabled(true);
    ui->btnLineOut->setEnabled(false);
    ui->btnStopListen->setEnabled(false);
}

/**
 * “断开连接”按钮点击事件处理函数
 * 停止监听并删除服务器实例，关闭当前窗口
 */
void Widget::on_btnLineOut_clicked()
{
    // 调用停止监听函数
    on_btnStopListen_clicked();

    // 删除服务器实例
    delete server;

    // 关闭当前窗口
    this->close();
}

---

✅ 功能说明

函数	功能
构造函数	初始化 UI、创建 TCP 服务器、填充本地 IPv4 地址到下拉框
on_newClient_connect	处理新客户端连接，记录地址端口、连接信号
on_readyRead_handler	接收客户端发送的数据并在界面上显示
mdisconnected	客户端断开连接时更新界面并释放 socket 资源
mstateChanged	客户端连接状态变化时更新界面信息
mComboBox_refresh	刷新组合框内容，显示所有已连接客户端的端口号
on_btnList_clicked	启动服务器监听，失败时弹出提示框并更新按钮状态
on_btnSend_clicked	根据用户选择，将 textEditSend 内容发送给所有或特定客户端
on_comboBoxChildren_activated	更新 childIndex 以标识用户选择的客户端
on_btnStopListen_clicked	关闭所有客户端连接并停止服务器监听
on_btnLineOut_clicked	停止监听并删除服务器实例，关闭当前窗口

---

📝 注意事项

• findChildren<QTcpSocket*>() 用于查找所有直接或间接属于 server 的 QTcpSocket 子对象。此方法会找到所有已连接的客户端。
• tmp->write(...) 方法用于向客户端发送数据。注意，这里使用了 toStdString().c_str() 来进行转换，这可能不是最佳实践，建议使用 QByteArray 或者其他方式来避免潜在的编码问题。
• mComboBox_refresh() 函数通过遍历所有已连接的客户端并将它们的端口号添加到组合框中，允许用户选择特定客户端进行数据通信。