Qt中使用QUdpSocket类实现UDP通信

快来打我* 2023-06-25 10:24 38阅读 0赞

在QT中使用QUdpSocket类用于实现UDP通信，它从QAbstractSocket类继承，因而与QTcpSocket共享大部分的接口函数。主要区别是QUdpSocket以数据报传输数据，而不是以连续的数据流。发送数据报使用函数QUdpSocket：：writeDatagram()，数据报的长度一般不少于512字节，每个数据报包含发送者和接收者的IP地址和端口等信息。

要进行UDP数据接收，要用QUdpSocket::bind()函数先绑定一个端口，用于接收传入的数据报。当有数据报传入时会发射readRead()信号，使用readDatagram()函数来读取接收的数据报。

UDP消息传送有单播、广播、组播三种模式，其示意图如下：

![20191228145200964.png][]![20191228145217388.png][]![20191228145222566.png][]

单播                              广播                                 组播

图：UDP客户端之间通信的三种模式

单播（unicast）模式：一个UDP客户端发出的数据报只发送到另一个指定地址和端口的UDP客户端，是一对一的数据传输。

广播（broadcast）模式：一个UDP客户端发出的数据报，在同一网络范围内其他所有的UDP客户端都可以收到。QUdpSocket支持IPv4广播。广播经常用于实现网络发现的协议。要获取广播数据只需在数据报中指定接收端地址为QHostAddress::Broadcast,一般的广播地址为255.255.255.255。

组播（multicast）模式：也称为多播。UDP客户端加入到另一组播IP地址指定的多播组，成员向多组播地址发送的数据报组内成员都可以接收到，类似于QQ群的功能。

接下来实现UDP单播和广播的功能，其主窗口是继承自QMainWindow的类，界面用UI设计器设计。程序可以进行UDP数据报 的发送和接收。

通过同时打开两个这个程序，可以实现UDP通信，注意：在同一台计算机上运行时，两个运行实例需要绑定不同的端口。

设计的界面如下：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xodzE5OTMxMjAx_size_16_color_FFFFFF_t_70][]

头文件mainwindow.h：

#ifndef MAINWINDOW_H
    #define MAINWINDOW_H
    
    #include <QMainWindow>
    #include <QUdpSocket>
    #include <QLabel>
    namespace Ui {
    class MainWindow;
    }
    
    class MainWindow : public QMainWindow
    {
        Q_OBJECT
    
    private:
        QLabel *LabSocketState; //socket状态显示标签
        QUdpSocket *udpSocket;  //定义QUdpSocket类的私有变量udpSocket用于UDP通信
        QString getLocalIP(); //获取本机IP地址
    
    public:
        explicit MainWindow(QWidget *parent = 0);
        ~MainWindow();
    
    private slots:
        //自定义槽函数
        void    onSocketStateChange(QAbstractSocket::SocketState socketState); //显示udpSocket当前的状态
        void    onSocketReadyRead();//读取socket传入的数据，读取缓冲区数据报
    
        void on_actStart_triggered();
    
        void on_actStop_triggered();
    
        void on_actClear_triggered();
    
        void on_btnSend_clicked();
    
        void on_btnBroadcast_clicked();
    
        void on_actHostInfo_triggered();
    
    private:
        Ui::MainWindow *ui;
    };
    
    #endif // MAINWINDOW_H

源文件mainwindow.cpp:

#include "mainwindow.h"
    #include "ui_mainwindow.h"
    #include <QtNetwork>
    
    MainWindow::MainWindow(QWidget *parent) :
        QMainWindow(parent),
        ui(new Ui::MainWindow)
    {
        ui->setupUi(this);
        //创建状态栏上的标签用于信息显示
        LabSocketState=new QLabel("Socket状态：");
        LabSocketState->setMinimumWidth(200);
        ui->statusBar->addWidget(LabSocketState);
    
        QString localIP=getLocalIP();//获取本机IP地址
        this->setWindowTitle(this->windowTitle()+"----本机IP："+localIP);
        ui->comboTargetIP->addItem(localIP);
    
        udpSocket=new QUdpSocket(this);
        //关联信号与自定义槽函数
        connect(udpSocket,SIGNAL(stateChanged(QAbstractSocket::SocketState)),
                this,SLOT(onSocketStateChange(QAbstractSocket::SocketState)));
        onSocketStateChange(udpSocket->state());
    
        connect(udpSocket,SIGNAL(readyRead()),
                this,SLOT(onSocketReadyRead()));
    }
    
    MainWindow::~MainWindow()
    {
        delete ui;
        udpSocket->abort();
        delete udpSocket;
    }
    
    QString MainWindow::getLocalIP()
    {
        //获取本机IPv4地址
        QString hostName=QHostInfo::localHostName();//本地主机名
        QHostInfo   hostInfo=QHostInfo::fromName(hostName);//本机IP地址
        QString   localIP="";
    
        QList<QHostAddress> addList=hostInfo.addresses();//通过addresses()获取主机IP地址列表，addList是一个列表
    
        if (!addList.isEmpty())
        for (int i=0;i<addList.count();i++)
        {
            QHostAddress aHost=addList.at(i); //每一项是一个QHostAddress
            if (QAbstractSocket::IPv4Protocol==aHost.protocol()) //IPv4协议，protocol()返回当前IP地址的协议类型
            {
                localIP=aHost.toString(); //范围IP地址字符串
                break;
            }
        }
        return localIP;
    }
    
    void MainWindow::onSocketStateChange(QAbstractSocket::SocketState socketState)
    {
        switch(socketState)
        {
        case QAbstractSocket::UnconnectedState:
            LabSocketState->setText("scoket状态：UnconnectedState");
            break;
        case QAbstractSocket::HostLookupState:
            LabSocketState->setText("scoket状态：HostLookupState");
            break;
        case QAbstractSocket::ConnectingState:
            LabSocketState->setText("scoket状态：ConnectingState");
            break;
    
        case QAbstractSocket::ConnectedState:
            LabSocketState->setText("scoket状态：ConnectedState");
            break;
    
        case QAbstractSocket::BoundState:
            LabSocketState->setText("scoket状态：BoundState");
            break;
    
        case QAbstractSocket::ClosingState:
            LabSocketState->setText("scoket状态：ClosingState");
            break;
    
        case QAbstractSocket::ListeningState:
            LabSocketState->setText("scoket状态：ListeningState");
        }
    }
    
    void MainWindow::onSocketReadyRead()
    {
        //读取收到的数据报
        //hasPendingDatagrams()表示是否有待读取的传入数据报
        while(udpSocket->hasPendingDatagrams())
        {
            QByteArray   datagram; //数据报是QByteArray类型的字节数组
            datagram.resize(udpSocket->pendingDatagramSize());
    
            QHostAddress    peerAddr;
            quint16 peerPort;
            udpSocket->readDatagram(datagram.data(),datagram.size(),&peerAddr,&peerPort);
            QString str=datagram.data();
    
            QString peer="[From "+peerAddr.toString()+":"+QString::number(peerPort)+"] ";
    
            ui->plainTextEdit->appendPlainText(peer+str);
        }
    }
    void MainWindow::on_actStart_triggered()
    {
        //绑定端口
        //要实现UDP数据的接收，必须先用bind()绑定一个端口，用于监听传入的数据报
        quint16     port=ui->spinBindPort->value(); //本机UDP端口
        if (udpSocket->bind(port))//绑定端口成功
        {
            ui->plainTextEdit->appendPlainText("**已成功绑定");
            ui->plainTextEdit->appendPlainText("**绑定端口："
                                               +QString::number(udpSocket->localPort()));
    
            ui->actStart->setEnabled(false);
            ui->actStop->setEnabled(true);
        }
        else
            ui->plainTextEdit->appendPlainText("**绑定失败");
    }
    
    void MainWindow::on_actStop_triggered()
    {
        //解除绑定
        udpSocket->abort(); //不能解除绑定
        ui->actStart->setEnabled(true);
        ui->actStop->setEnabled(false);
        ui->plainTextEdit->appendPlainText("**已解除绑定");
    }
    
    void MainWindow::on_actClear_triggered()
    {
         ui->plainTextEdit->clear();
    }
    
    void MainWindow::on_btnSend_clicked()
    {
        //发送消息 按钮
        QString     targetIP=ui->comboTargetIP->currentText(); //目标IP
        QHostAddress    targetAddr(targetIP);
    
        quint16     targetPort=ui->spinTargetPort->value();//目标port
    
        QString  msg=ui->editMsg->text();//发送的消息内容
    
        QByteArray  str=msg.toUtf8();
        udpSocket->writeDatagram(str,targetAddr,targetPort); //发出数据报
    
        ui->plainTextEdit->appendPlainText("[out] "+msg);
        ui->editMsg->clear();
        ui->editMsg->setFocus();
    }
    
    void MainWindow::on_btnBroadcast_clicked()
    {
        //广播消息 按钮
        quint16     targetPort=ui->spinTargetPort->value(); //目标端口
        QString  msg=ui->editMsg->text();
        QByteArray  str=msg.toUtf8();
        udpSocket->writeDatagram(str,QHostAddress::Broadcast,targetPort);
    
        ui->plainTextEdit->appendPlainText("[broadcast] "+msg);
        ui->editMsg->clear();
        ui->editMsg->setFocus();
    }
    
    
    
    void MainWindow::on_actHostInfo_triggered()
    {
        //获取本机地址
        QString hostName=QHostInfo::localHostName();//本地主机名
        ui->plainTextEdit->appendPlainText("本机主机名："+hostName+"\n");
        QHostInfo   hostInfo=QHostInfo::fromName(hostName);
    
        QList<QHostAddress> addList=hostInfo.addresses();//
        if (!addList.isEmpty())
            for (int i=0;i<addList.count();i++)
            {
                QHostAddress aHost=addList.at(i);
                if (QAbstractSocket::IPv4Protocol==aHost.protocol())
                {
                    QString IP=aHost.toString();
                    ui->plainTextEdit->appendPlainText("本机IP地址："+aHost.toString());
                    if (ui->comboTargetIP->findText(IP)<0)
                        ui->comboTargetIP->addItem(IP);
                }
            }
    }

编译运行后，同时运行两个这个程序进行UDP通信：绑定发送端的端口号后，将接收端的目标端口设为这个一样的。

发送端的界面如下：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xodzE5OTMxMjAx_size_16_color_FFFFFF_t_70 1][]

此时接收端为：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xodzE5OTMxMjAx_size_16_color_FFFFFF_t_70 2][]

[20191228145200964.png]: https://img-blog.csdnimg.cn/20191228145200964.png
[20191228145217388.png]: https://img-blog.csdnimg.cn/20191228145217388.png
[20191228145222566.png]: https://img-blog.csdnimg.cn/20191228145222566.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xodzE5OTMxMjAx_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20191228153235162.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xodzE5OTMxMjAx,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xodzE5OTMxMjAx_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20191228153509608.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xodzE5OTMxMjAx,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xodzE5OTMxMjAx_size_16_color_FFFFFF_t_70 2]: https://img-blog.csdnimg.cn/20191228153529425.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xodzE5OTMxMjAx,size_16,color_FFFFFF,t_70