• Qt —UDP通信QUdpSocket 简介 +案例

    1. UDP通信概述


       UDP是无连接、不可靠、面向数据报（datagram）的协议，可以应用于对可靠性要求不高的场合。与TCP通信不同，UDP通信无需预先建立持久的socket连接，UDP每次发送数据报都需要指定目标地址和端口。

       QUdpSocket以数据报传输数据，而不是以连续的数据流。发送数据报使用函数         QUdpSocket::writeDatagram()，数据报的长度一般少于512字节，每个数据报包含发送者和接收者的IP地址和端口等信息。
         UDP数据接收，首先要使用QUdpSocket::bind()绑定一个端口，绑定端口后，socket的状态会变为已绑定状态“BoundState”。

    当有数据报传入时，QudpSocket会自动发射readyRead()信号，在其槽函数中使用QUdpSocket::readDatagram()进行数据读取。abort()为解除绑定，解除后socket状态变为未连接状态“UnconnectedState”。

    2. UDP消息传送的三种模式

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

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

    组播模式（multicast）：UDP客户端加入到另一个组播IP地址的多播组，成员向组播地址发送的数据报，其加入组播的所有成员都可以接收到，类似于QQ群功能。QUdpSocket::joinMulticastGroup()函数实现加入多播组的功能。

    QUdpSocket::leaveMulticastGroup()函数实现

    在单播、广播和多播模式下，UDP程序都是对等的，不像TCP通信分为客户端和服务端。
    TCP通信只有单播模式。UDP通信虽然不能保证数据传输的准确性，但是具有灵活性，一般的即时通信软件都是基于UDP通信的。

    3. QUdpSocket类的接口函数

    bool bind(quint16 port = 0)  为UDP通信绑定一个端口

    qint64 writeDatagram(QByteArray& datagram, QHostAddress& host, quint16 port) 向目标地址和端口的UDP客户端发送数据报，返回成功发送的字节数，数据报的长度一般不超过512字节。

    bool hasPendingDatagrams()     当至少有一个数据报需要读取时，返回true

    qint64 pendingDatagramSize()    返回第一个待读取的数据报的大小

    qint64 readDatagram(char* data, qint64 maxSize) 读取一个数据报，返回成功读取的字节数

    qint64 readDatagram(char* data, qint64 maxSize, QHostAddress* address, quint16* port) 读取一个数据报，返回成功读取的字节数。发送方的主机地址和端口存储在*address和*port中(除非指针为0)

    bool joinMulticastGroup(QHostAddress& groupAddress)      加入一个多播组

    bool leaveMulticastGroup(QHostAddress& groupAddress)    离开一个多播组

    void abort() 终止当前连接并重置套接字。通常在析构函数中写入。与disconnectFromHost()不同，该函数立即关闭套接字，丢弃写入缓冲区中的任何挂起数据。
    原文链接：https://blog.csdn.net/WL0616/article/details/129050373

    4.UDP对话小案例

    实现发送和接收端互相发信息，类似QQ  (界面使用UI设计)

    4.1.接收端

    receiver.h

    1. #ifndef RECESIVER_H
    2. #define RECESIVER_H
    3.  
    4. #include 
    5. #include 
    6. QT_BEGIN_NAMESPACE
    7. namespace Ui { class Recesiver; }
    8. QT_END_NAMESPACE
    9.  
    10. class Recesiver : public QWidget
    11. {
    12.     Q_OBJECT
    13.  
    14. public:
    15.     Recesiver(QWidget *parent = nullptr);
    16.     ~Recesiver();
    17.  
    18. private slots:
    19.     void on_pushButton_2_clicked(); //启动槽函数
    20.     void start();
    21.     void on_pushButton_clicked();
    22.  
    23. private:
    24.     Ui::Recesiver *ui;
    25.     QUdpSocket *receiver;
    26. };
    27. #endif // RECESIVER_H

    receiver.cpp

    1. #include "recesiver.h"
    2. #include "ui_recesiver.h"
    3.  
    4. Recesiver::Recesiver(QWidget *parent)
    5.     : QWidget(parent)
    6.     , ui(new Ui::Recesiver)
    7. {
    8.     ui->setupUi(this);
    9.     setWindowTitle(QStringLiteral("接收端"));
    10.     ui->lineEdit->setText("127.0.0.1");
    11.     receiver =new QUdpSocket(this);
    12. }
    13.  
    14. Recesiver::~Recesiver()
    15. {
    16.     delete ui;
    17. }
    18.  
    19. //接收信息
    20.  void Recesiver::start()
    21.  {
    22.     QByteArray datagram;
    23.     datagram.resize(receiver->pendingDatagramSize()); //接收到的数据的长度
    24.     receiver->readDatagram(datagram.data(),datagram.size());
    25.     ui->textEdit->append(QStringLiteral("对方：")+datagram);
    26.  }
    27.  
    28. //启动按钮（发送端发送信息给接收端）
    29. void Recesiver::on_pushButton_2_clicked()
    30. {
    31.    receiver->bind(ui->lineEdit_2->text().toInt());//设置端口号将其转为整型
    32.    connect(receiver,&QUdpSocket::readyRead,this,[&](){start();});
    33.    ui->pushButton_2->setEnabled(false);
    34.    ui->lineEdit_2->setEnabled(false);
    35. }
    36.  
    37. //发送按钮（接收端发送信息给发送端）
    38. void Recesiver::on_pushButton_clicked()
    39. {
    40.     QByteArray datagram=ui->textEdit_2->toPlainText().toUtf8();  //在输入端输入发送的内容
    41.     receiver->writeDatagram(datagram.data(),datagram.size(),QHostAddress(ui->lineEdit->text()),ui->lineEdit_3->text().toInt());
    42.     //qint64 writeDatagram(const char *data, qint64 len, const QHostAddress &host, quint16 port);
    43.     //发送数据，大小，发送主机的ip,发送主机的端口号
    44.     ui->textEdit->append(QStringLiteral("本机：")+ui->textEdit_2->toPlainText());//发送信息的具体内容在发送端的聊天记录里能体现
    45.     ui->textEdit_2->clear();
    46. }

    4.2发送端

    sender.h

    1. #ifndef SENDER_H
    2. #define SENDER_H
    3. #include 
    4. #include 
    5. QT_BEGIN_NAMESPACE
    6. namespace Ui { class Sender; }
    7. QT_END_NAMESPACE
    8.  
    9. class Sender : public QWidget
    10. {
    11.     Q_OBJECT
    12.  
    13. public:
    14.     Sender(QWidget *parent = nullptr);
    15.     ~Sender();
    16.     void  start2();
    17. private slots:
    18.     void on_pushButton_clicked();
    19.  
    20. private:
    21.     Ui::Sender *ui;
    22.     QUdpSocket *sender;
    23. };
    24. #endif // SENDER_H

    sender.cpp

    1. #include "sender.h"
    2. #include "ui_sender.h"
    3.  
    4. Sender::Sender(QWidget *parent)
    5.     : QWidget(parent)
    6.     , ui(new Ui::Sender)
    7. {
    8.     ui->setupUi(this);
    9.     sender=new QUdpSocket(this);
    10.     setWindowTitle(QStringLiteral("发送端"));
    11.  
    12.     //sender
    13.     ui->lineEdit_3->setText("888");
    14.     sender->bind(ui->lineEdit_3->text().toInt());//绑定端口号
    15.  
    16.     connect(sender,&QUdpSocket::readyRead,this,[&](){start2();});
    17.     //start2();
    18. }
    19.  
    20. void Sender::start2()
    21. {
    22.     QByteArray datagram;
    23.     datagram.resize(sender->pendingDatagramSize()); //接收到的数据的长度
    24.     sender->readDatagram(datagram.data(),datagram.size());
    25.     ui->textEdit->append(QStringLiteral("对方：")+datagram);
    26. }
    27.  
    28.  
    29. Sender::~Sender()
    30. {
    31.     delete ui;
    32. }
    33.  
    34.  
    35. //发送按钮 发送信息给接收端
    36. void Sender::on_pushButton_clicked()
    37. {
    38.    QByteArray datagram=ui->textEdit_2->toPlainText().toUtf8();  //在输入端输入发送的内容
    39.    sender->writeDatagram(datagram.data(),datagram.size(),QHostAddress(ui->lineEdit->text()),ui->lineEdit_2->text().toInt());
    40.    //qint64 writeDatagram(const char *data, qint64 len, const QHostAddress &host, quint16 port);
    41.    //发送数据，大小，发送主机的ip,发送主机的端口号
    42.    ui->textEdit->append(QStringLiteral("本机：")+ui->textEdit_2->toPlainText());//发送信息的具体内容在发送端的聊天记录里能体现
    43.    ui->textEdit_2->clear();
    44.  
    45. }

    结果：

    （ps：对话有点搞笑，哈哈哈）

    5.4. UDP单播和广播代码示例

    4.1 测试说明

      本实例实现UDP通信的单播和广播。两个实例可以运行在同一台计算机上，也可以运行在不同的计算机上。
    这里的两个实例是运行在同一台计算机上，需要注意，在同一台计算机上运行时，两个实例需要绑定不同的端口。例如实例A绑定端口1600，实例B绑定端口3200，实例A向实例B发送数据报时，需要指定实例B的端口，这样实例B才能收到数据。
    如果两个实例在不同的计算机上运行，则端口可以一样，因为IP地址不同了，不会导致绑定时发生冲突。一般的UDP通信程序都是在不同的计算机上运行的，约定一个固定的端口作为通信端口。

    4.2主要程序

    用UI设计器件和代码化UI分别设计

    ui设计器设计：

    .h

    1. #ifndef MAINWINDOW_H
    2. #define MAINWINDOW_H
    3.  
    4. #include 
    5. #include 
    6. #include 
    7. #include 
    8. QT_BEGIN_NAMESPACE
    9. namespace Ui { class MainWindow; }
    10. QT_END_NAMESPACE
    11.  
    12. class MainWindow : public QMainWindow
    13. {
    14.     Q_OBJECT
    15.  
    16. public:
    17.     MainWindow(QWidget *parent = nullptr);
    18.     ~MainWindow();
    19.     void   handleEvents();                                                 // 信号与槽处理
    20.  
    21. private:
    22.     Ui::MainWindow *ui;
    23.  
    24.     QUdpSocket *udpScoket;
    25.     QLabel *labstateScoket;   //Scoket状态栏标签
    26.     QString  getLocalIp();  //获取本机的IP地址
    27. private slots:
    28.  
    29.     void slotActBindPort();   //绑定端口
    30.     void slotActUnbindPort(); //解除端口
    31.     void slotActClearText();  //清空文本框
    32.     void slotActQuit();       //退出
    33.  
    34.     void slotSocketReadyRead();  //读取socket传入的数据
    35.     void slotSocketStateChanged(QAbstractSocket::SocketState socketState);
    36.  
    37.     void on_pushButton_clicked(); //发送信息
    38.     void on_pushButton_2_clicked(); //广播信息
    39. };
    40. #endif // MAINWINDOW_H

    .cpp

    1. #include "mainwindow.h"
    2. #include "ui_mainwindow.h"
    3. #include 
    4. #include 
    5. #include 
    6.  
    7. #include 
    8. #include 
    9. MainWindow::MainWindow(QWidget *parent)
    10.     : QMainWindow(parent)
    11.     , ui(new Ui::MainWindow)
    12. {
    13.     ui->setupUi(this);
    14.  
    15.     QString localIP = getLocalIp(); //获取本机的IP地址
    16.     this->setWindowTitle(this->windowTitle() + "---IP:" + localIP);
    17.  
    18.     ui->comboBox->addItem(localIP); //在目标地址中添加IP
    19.     udpScoket = new QUdpSocket(this);
    20.  
    21.     //状态栏
    22.     labstateScoket = new QLabel(QStringLiteral("socket状态："), this);
    23.     labstateScoket->setMinimumWidth(150);
    24.     ui->statusBar->addWidget(labstateScoket);
    25.     handleEvents();
    26.  
    27.     ui->spinBox->setMinimum(1);     //设置绑定端口的最大最小值和当前的端口值
    28.     ui->spinBox->setMaximum(65535);
    29.     ui->spinBox->setValue(1600);
    30.  
    31.     ui->spinBox_2->setMinimum(1);   //设置目标端口的最大最小值和当前的端口值
    32.     ui->spinBox_2->setMaximum(65535);
    33.     ui->spinBox_2->setValue(3200);
    34.  
    35. }
    36.  
    37. MainWindow::~MainWindow()
    38. {
    39.     udpScoket->abort();
    40.     delete udpScoket;
    41.     udpScoket = nullptr;
    42.     delete ui;
    43. }
    44.  
    45.  
    46. // 信号与槽处理
    47. void MainWindow::handleEvents()
    48. {
    49.  
    50.     connect(ui->action, &QAction::triggered, this, &MainWindow::slotActBindPort );
    51.     connect(ui->action_2, &QAction::triggered, this, &MainWindow::slotActUnbindPort);
    52.     connect(ui->action_3, &QAction::triggered, this, &MainWindow::slotActClearText);
    53.     connect(ui->action_4, &QAction::triggered, this, &MainWindow::slotActQuit);
    54.  
    55.     connect(ui->pushButton, &QPushButton::clicked, this, &MainWindow::on_pushButton_clicked);
    56.     connect(ui->pushButton_2, &QPushButton::clicked, this, &MainWindow::on_pushButton_2_clicked);
    57.  
    58.     connect(udpScoket, &QUdpSocket::stateChanged, this, &MainWindow::slotSocketStateChanged);
    59.     connect(udpScoket, &QUdpSocket::readyRead, this, &MainWindow::slotSocketReadyRead);
    60.  
    61. }
    62.  
    63.  
    64. QString MainWindow::getLocalIp()
    65. {
    66.     QString hostName = QHostInfo::localHostName();//获取本机主机名
    67.     QHostInfo hostInfo = QHostInfo::fromName(hostName);  //返回主机名的IP地址
    68.  
    69.     QString localIP = "";
    70.     QList addrList = hostInfo.addresses();   //主机IP地址列表
    71.  
    72.     if (!addrList.isEmpty())
    73.     {
    74.         for (int i = 0; i < addrList.size(); i++)
    75.         {
    76.             QHostAddress addr = addrList.at(i);
    77.             if (QAbstractSocket::IPv4Protocol == addr.protocol())
    78.             {
    79.                 localIP = addr.toString();
    80.                 break;
    81.             }
    82.         }
    83.     }
    84.     return localIP;
    85. }
    86.  
    87.  
    88. //绑定端口
    89. void MainWindow::slotActBindPort()
    90. {
    91.     quint16 port=ui->spinBox->value();   //绑定本机UDp端口
    92.     if(udpScoket->bind(port))
    93.     {
    94.         ui->textEdit->append(QStringLiteral("**已经绑定成功"));
    95.         ui->textEdit->append(QStringLiteral("**绑定端口：")+QString::number(udpScoket->localPort()));
    96.         ui->action->setEnabled(false); //开始绑定失效
    97.         ui->action_2->setEnabled(true);//解除绑定使能
    98.     }
    99.     else
    100.         ui->textEdit->append(QStringLiteral("绑定失败"));
    101. }
    102.  
    103. //解除端口
    104. void MainWindow::slotActUnbindPort()
    105. {
    106.  
    107.     udpScoket->abort();//解除绑定
    108.     ui->action->setEnabled(true); //开始绑定失效
    109.     ui->action_2->setEnabled(false);//解除绑定使能
    110.     ui->textEdit->append(QStringLiteral("**已经解除绑定"));
    111.  
    112. }
    113.  
    114. //清空文本框
    115. void MainWindow::slotActClearText()
    116. {
    117.     ui->textEdit->clear();
    118. }
    119.  
    120.  
    121. //退出
    122. void MainWindow::slotActQuit()
    123. {
    124.     QMessageBox::StandardButton button = QMessageBox::question(this, "", QStringLiteral("是否要退出？"));
    125.     if (button == QMessageBox::StandardButton::Yes)
    126.         this->close();
    127. }
    128.  
    129. //读取socket传入的数据
    130. void MainWindow::slotSocketReadyRead()
    131. {
    132.     while(udpScoket->hasPendingDatagrams()) //当有数据传入数据报
    133.      {
    134.        QByteArray  datagtam;
    135.        datagtam.resize(udpScoket->pendingDatagramSize());//读取数据报大小
    136.  
    137.        QHostAddress peerAddr;  //在已连接的状态下，返回对方的socket的地址
    138.        quint16 peerPort;       //在已连接的状态下，返回对方的socket的端口
    139.  
    140.        udpScoket->readDatagram(datagtam.data(),datagtam.size(),&peerAddr,&peerPort);//读取数据报的内容
    141.        //qint64 readDatagram(char *data, qint64 maxlen, QHostAddress *host = nullptr, quint16 *port = nullptr);
    142.  
    143.        QString str=datagtam.data();
    144.        QString  peer="[From "+peerAddr.toString()+":"+QString::number(peerPort)+"]";
    145.        ui->textEdit->append( peer + str);
    146.      }
    147. }
    148.  
    149.  //状态栏显示Socket变化情况
    150. void MainWindow::slotSocketStateChanged(QAbstractSocket::SocketState socketState)
    151. {
    152.     switch (socketState)
    153.     {
    154.             case QAbstractSocket::UnconnectedState: labstateScoket->setText(QStringLiteral("socket状态：UnconnectedState")); break;
    155.             case QAbstractSocket::HostLookupState: labstateScoket->setText(QStringLiteral("socket状态：HostLookupState")); break;
    156.             case QAbstractSocket::ConnectingState: labstateScoket->setText(QStringLiteral("socket状态：ConnectingState")); break;
    157.             case QAbstractSocket::ConnectedState: labstateScoket->setText(QStringLiteral("socket状态：ConnectedState")); break;
    158.             case QAbstractSocket::BoundState: labstateScoket->setText(QStringLiteral("socket状态：BoundState")); break;
    159.             case QAbstractSocket::ClosingState: labstateScoket->setText(QStringLiteral("socket状态：ClosingState")); break;
    160.             default: break;
    161.      }
    162.  
    163. }
    164.  
    165.  
    166. //发送信息
    167. void MainWindow::on_pushButton_clicked()
    168. {
    169.         QString msg = ui->lineEdit->text(); //发送信息
    170.         QByteArray str = msg.toUtf8();
    171.  
    172.         QString targetIp = ui->comboBox->currentText();  //目标IP就是主机地址的ip
    173.         QHostAddress targetAddr(targetIp);
    174.         quint16 targetPort = ui->spinBox_2->value();  //目标端口
    175.  
    176.         udpScoket->writeDatagram(str, targetAddr, targetPort);//发出数据报
    177.         ui->textEdit->append("[out] " + msg);
    178.         ui->lineEdit->clear();
    179.         ui->lineEdit->setFocus();
    180.  
    181. }
    182. //广播信息
    183. void MainWindow::on_pushButton_2_clicked()
    184. {
    185.       quint16 targetPort = ui->spinBox_2->value();  //目标端口
    186.       QString msg=ui->lineEdit->text();
    187.  
    188.       QByteArray str = msg.toUtf8();
    189.       udpScoket->writeDatagram(str, QHostAddress::Broadcast, targetPort);//发出数据报
    190.       ui->textEdit->append("[broadcast] " + msg);
    191.       ui->lineEdit->clear();
    192.       ui->lineEdit->setFocus();
    193.  
    194. }

    代码化：

    .h

    1. #ifndef MAINWINDOW_H
    2. #define MAINWINDOW_H
    3.  
    4. #include 
    5. #include 
    6. #include 
    7. #include 
    8. #include 
    9. #include 
    10. #include 
    11. #include 
    12. #include 
    13. #include 
    14. #include 
    15. #include 
    16. #include 
    17. #include 
    18.  
    19. namespace Ui {
    20.     class MainWindow;
    21. }
    22.  
    23. class MainWindow : public QMainWindow {
    24.     Q_OBJECT
    25.  
    26. public:
    27.     explicit MainWindow(QWidget* parent = 0);
    28.     ~MainWindow();
    29.  
    30. private slots:
    31.     void slotActBindPort();
    32.     void slotActUnbindPort();
    33.     void slotActClearText();
    34.     void slotActQuit();
    35.     void slotSocketStateChanged(QAbstractSocket::SocketState socketState);
    36.     void slotBtnSend();
    37.     void slotBtnBroad();
    38.     void slotSocketReadyRead();  //读取socket传入的数据
    39.  
    40. private:
    41.     Ui::MainWindow* ui;
    42.  
    43.     QAction* m_pActBindPort;
    44.     QAction* m_pActUnbindPort;
    45.     QAction* m_pActClearText;
    46.     QAction* m_pActQuit;
    47.     QWidget* m_pCentralWidget;
    48.     QLabel* m_pLabBindPort;
    49.     QLabel* m_PLabTargetAddr;
    50.     QLabel* m_pLabTargetPort;
    51.     QSpinBox* m_pSpinBindPort;
    52.     QComboBox* m_pComboTargetAddr;
    53.     QSpinBox* m_pSpinTargetPort;
    54.     QLineEdit* m_pLineEdit;
    55.     QPushButton* m_pBtnSend;
    56.     QPushButton* m_pBtnBroad;
    57.     QPlainTextEdit* m_pPlainText;
    58.     QLabel* m_pLabState;
    59.     QUdpSocket* m_pUdpSocket;
    60.  
    61.     QString getLocalIP();
    62. };
    63.  
    64. #endif  // MAINWINDOW_H

    .cpp

    1. #include "mainwindow.h"
    2. #include 
    3. #include "ui_mainwindow.h"
    4.  
    5. MainWindow::MainWindow(QWidget* parent) : QMainWindow(parent), ui(new Ui::MainWindow) {
    6.     ui->setupUi(this);
    7.     //this->setWindowIcon(QIcon(":/new/prefix1/res/TitleIcon.png"));
    8.     this->setWindowTitle(QStringLiteral("UDP Send/Receiver"));
    9.  
    10.     //工具栏
    11.     ui->toolBar->setToolButtonStyle(Qt::ToolButtonTextBesideIcon);
    12.     m_pActBindPort = new QAction(QIcon(":/new/Check.png"), QStringLiteral("绑定端口"), this);
    13.     m_pActUnbindPort = new QAction(QIcon(":/new/Break.png"), QStringLiteral("结束绑定"), this);
    14.     m_pActClearText = new QAction(QIcon(":/new/remove.png"), QStringLiteral("清空文本"), this);
    15.     m_pActQuit = new QAction(QIcon(":/new/back.png"), QStringLiteral("退出"), this);
    16.     ui->toolBar->addAction(m_pActBindPort);
    17.     ui->toolBar->addAction(m_pActUnbindPort);
    18.     ui->toolBar->addSeparator();
    19.     ui->toolBar->addAction(m_pActClearText);
    20.     ui->toolBar->addSeparator();
    21.     ui->toolBar->addAction(m_pActQuit);
    22.  
    23.     //界面布局
    24.     m_pCentralWidget = new QWidget(this);
    25.  
    26.     QHBoxLayout* HLay1 = new QHBoxLayout;
    27.     m_pLabBindPort = new QLabel(QStringLiteral("绑定端口"), m_pCentralWidget);
    28.     m_pSpinBindPort = new QSpinBox(m_pCentralWidget);
    29.     m_pSpinBindPort->setMinimum(1);
    30.     m_pSpinBindPort->setMaximum(65535);
    31.     m_pSpinBindPort->setValue(3200);
    32.     m_PLabTargetAddr = new QLabel(QStringLiteral("目标地址"), m_pCentralWidget);
    33.     m_pComboTargetAddr = new QComboBox(m_pCentralWidget);
    34.     m_pLabTargetPort = new QLabel(QStringLiteral("目标端口"), m_pCentralWidget);
    35.     m_pSpinTargetPort = new QSpinBox(m_pCentralWidget);
    36.     m_pSpinTargetPort->setMinimum(1);
    37.     m_pSpinTargetPort->setMaximum(65535);
    38.     m_pSpinTargetPort->setValue(1600);
    39.     HLay1->addWidget(m_pLabBindPort, 1, Qt::AlignRight);
    40.     HLay1->addWidget(m_pSpinBindPort, 2);
    41.     HLay1->addWidget(m_PLabTargetAddr, 1, Qt::AlignRight);
    42.     HLay1->addWidget(m_pComboTargetAddr, 4);
    43.     HLay1->addWidget(m_pLabTargetPort, 1, Qt::AlignRight);
    44.     HLay1->addWidget(m_pSpinTargetPort, 2);
    45.  
    46.     QHBoxLayout* HLay2 = new QHBoxLayout;
    47.     m_pLineEdit = new QLineEdit(m_pCentralWidget);
    48.     m_pBtnSend = new QPushButton(QStringLiteral("发送消息"), m_pCentralWidget);
    49.     m_pBtnBroad = new QPushButton(QStringLiteral("广播消息"), m_pCentralWidget);
    50.     HLay2->addWidget(m_pLineEdit);
    51.     HLay2->addWidget(m_pBtnSend);
    52.     HLay2->addWidget(m_pBtnBroad);
    53.  
    54.     QVBoxLayout* VLay = new QVBoxLayout(m_pCentralWidget);  //主布局必须设置parent，否则不会显示布局
    55.     // QVBoxLayout* VLay = new QVBoxLayout();
    56.     VLay->addLayout(HLay1);
    57.     VLay->addLayout(HLay2);
    58.     m_pPlainText = new QPlainTextEdit(m_pCentralWidget);
    59.     VLay->addWidget(m_pPlainText);
    60.  
    61.     this->setCentralWidget(m_pCentralWidget);
    62.     this->setLayout(VLay);  //设置为窗体的主布。在指定了主布局的parent之后，这句话可有可无
    63.  
    64.     QString localIP = getLocalIP();
    65.     this->setWindowTitle(this->windowTitle() + "---IP:" + localIP);
    66.     m_pComboTargetAddr->addItem(localIP);
    67.     m_pUdpSocket = new QUdpSocket(this);
    68.  
    69.     //状态栏
    70.     m_pLabState = new QLabel(QStringLiteral("socket状态："), this);
    71.     m_pLabState->setMinimumWidth(150);
    72.     ui->statusbar->addWidget(m_pLabState);
    73.  
    74.     // connect
    75.     connect(m_pActBindPort, &QAction::triggered, this, &MainWindow::slotActBindPort);
    76.     connect(m_pActUnbindPort, &QAction::triggered, this, &MainWindow::slotActUnbindPort);
    77.     connect(m_pActClearText, &QAction::triggered, this, &MainWindow::slotActClearText);
    78.     connect(m_pActQuit, &QAction::triggered, this, &MainWindow::slotActQuit);
    79.     connect(m_pBtnSend, &QPushButton::clicked, this, &MainWindow::slotBtnSend);
    80.     connect(m_pBtnBroad, &QPushButton::clicked, this, &MainWindow::slotBtnBroad);
    81.     connect(m_pUdpSocket, &QUdpSocket::stateChanged, this, &MainWindow::slotSocketStateChanged);
    82.     connect(m_pUdpSocket, &QUdpSocket::readyRead, this, &MainWindow::slotSocketReadyRead);
    83. }
    84.  
    85. MainWindow::~MainWindow() {
    86.     //m_pUdpSocket->abort();
    87.     //delete m_pUdpSocket;
    88.     //m_pUdpSocket = nullptr;
    89.     delete ui;
    90. }
    91.  
    92. void MainWindow::slotActBindPort()
    93. {
    94.     quint16 port = m_pSpinBindPort->value();  //本机UDP端口
    95.     if (m_pUdpSocket->bind(port)) {
    96.         m_pPlainText->appendPlainText(QStringLiteral("**已成功绑定"));
    97.         m_pPlainText->appendPlainText(QStringLiteral("绑定端口：") + QString::number(m_pUdpSocket->localPort()));
    98.  
    99.         //使能
    100.         m_pActBindPort->setEnabled(false);
    101.         m_pActUnbindPort->setEnabled(true);
    102.     } else {
    103.         m_pPlainText->appendPlainText(QStringLiteral("绑定失败"));
    104.     }
    105. }
    106.  
    107. void MainWindow::slotActUnbindPort() {
    108.     m_pUdpSocket->abort();  //解除绑定
    109.     m_pPlainText->appendPlainText(QStringLiteral("**已解除绑定"));
    110.  
    111.     m_pActBindPort->setEnabled(true);
    112.     m_pActUnbindPort->setEnabled(false);
    113. }
    114.  
    115. void MainWindow::slotActClearText() { m_pPlainText->clear(); }
    116.  
    117. void MainWindow::slotActQuit() {
    118.     QMessageBox::StandardButton button = QMessageBox::question(this, "", QStringLiteral("是否要退出？"));
    119.     if (button == QMessageBox::StandardButton::Yes)
    120.         this->close();
    121. }
    122.  
    123. void MainWindow::slotSocketStateChanged(QAbstractSocket::SocketState socketState) {
    124.     switch (socketState)
    125.     {
    126.             case QAbstractSocket::UnconnectedState: m_pLabState->setText(QStringLiteral("socket状态：UnconnectedState")); break;
    127.             case QAbstractSocket::HostLookupState: m_pLabState->setText(QStringLiteral("socket状态：HostLookupState")); break;
    128.             case QAbstractSocket::ConnectingState: m_pLabState->setText(QStringLiteral("socket状态：ConnectingState")); break;
    129.             case QAbstractSocket::ConnectedState: m_pLabState->setText(QStringLiteral("socket状态：ConnectedState")); break;
    130.             case QAbstractSocket::BoundState: m_pLabState->setText(QStringLiteral("socket状态：BoundState")); break;
    131.             case QAbstractSocket::ClosingState: m_pLabState->setText(QStringLiteral("socket状态：ClosingState")); break;
    132.             default: break;
    133.      }
    134.  
    135. }
    136.  
    137. void MainWindow::slotBtnSend()
    138. {
    139.     QString msg = m_pLineEdit->text();
    140.     QByteArray str = msg.toUtf8();
    141.     QString targetIp = m_pComboTargetAddr->currentText();  //目标IP
    142.     QHostAddress targetAddr(targetIp);
    143.     quint16 targetPort = m_pSpinTargetPort->value();  //目标端口
    144.     m_pUdpSocket->writeDatagram(str, targetAddr, targetPort);
    145.     m_pPlainText->appendPlainText("[out] " + msg);
    146.     m_pLineEdit->clear();
    147.     m_pLineEdit->setFocus();
    148.  
    149. }
    150.  
    151. void MainWindow::slotBtnBroad()
    152. {
    153.     QString msg = m_pLineEdit->text();
    154.     QByteArray str = msg.toUtf8();
    155.     quint16 targetPort = m_pSpinTargetPort->value();
    156.     m_pUdpSocket->writeDatagram(str, QHostAddress::Broadcast, targetPort);
    157.     m_pPlainText->appendPlainText("[out] " + msg);
    158.     m_pLineEdit->clear();
    159.     m_pLineEdit->setFocus();
    160.  
    161.  
    162.  
    163. }
    164.  
    165. void MainWindow::slotSocketReadyRead()
    166. {
    167.     while (m_pUdpSocket->hasPendingDatagrams())
    168.     {
    169.         QByteArray dataGram;
    170.         dataGram.resize(m_pUdpSocket->pendingDatagramSize());
    171.         QHostAddress peerAddress;
    172.         quint16 peerPort;
    173.         m_pUdpSocket->readDatagram(dataGram.data(), dataGram.size(), &peerAddress, &peerPort);
    174.         QString str = dataGram.data();
    175.         QString peer = "[From " + peerAddress.toString() + ":" + QString::number(peerPort) + "]";
    176.         m_pPlainText->appendPlainText(peer + str);
    177.     }
    178. }
    179.  
    180. QString MainWindow::getLocalIP() {
    181.     QString hostName = QHostInfo::localHostName();
    182.     QHostInfo hostInfo = QHostInfo::fromName(hostName);
    183.     QString localIP = "";
    184.     QList addrList = hostInfo.addresses();
    185.     if (!addrList.isEmpty()) {
    186.         for (int i = 0; i < addrList.size(); i++) {
    187.             QHostAddress addr = addrList.at(i);
    188.             if (QAbstractSocket::IPv4Protocol == addr.protocol()) {
    189.                 localIP = addr.toString();
    190.                 break;
    191.             }
    192.         }
    193.     }
    194.     return localIP;
    195. }
    196.

    结果： 

     发现自己用UI设计时，发送信息总会出现两个发送信号，并且有一个是空白的，暂时还没有找到问题所在之处，嘤嘤嘤~(/≧▽≦)/

    5. UDP组播代码示例

    5.1 组播的特性

    组播报文的目的地址使用D类IP地址，D类地址不能出现在IP报文的地址字段。用同一个IP多播地址接收多播数据报的所有主机构成一个组，称为多播组（或组播组）。所有的信息接收者都加入一个组内，并且一旦加入后，流向组地址的数据报立即开始向接收者传输，组中的所有的成员都能接收到数据报。组中的成员是动态的，主机可以在任何人时间加入和离开组。

    关于组播IP地址，有以下约定：

    224.0.0.0 ~ 224.0.0.255   为预留的组播地址（永久组地址），地址224.0.0.0保留不做分配，其他地址供路由协议使用。
    224.0.1.0 ~ 224.0.1.255   是公用组播地址，可以用于Internet。
    224.0.2.0 ~ 238.255.255.255     为用户可用的组播地址（临时组地址），全网范围内有效。
    239.0.0.0 ~ 239.255.255.255     为本地管理组播地址，仅在特定的本地范围内有效。所以，若是在家庭或办公室局域网内测试UDP组播功能，可以使用这些IP。
    原文链接：https://blog.csdn.net/WL0616/article/details/129050373

    常量定义

    值

    描述

    QUdpSocket::ShareAddress

    0x1

    		1、允许其他服务绑定同样的地址和端口
    2、当多进程通过监听同一地址和端口，进而共享单个服务的负载时，将十分有用(例如：一个拥有几个预先建立的监听者的WEB服务器能够改善响应时间)。不过，由于任何服务都允许重新绑定(rebind)，该选项应该引起某些安全上的考虑
    3、需要注意的是，把该选项和ReuseAddressHint结合，也会允许你的服务重新绑定一个已存在的共享地址
    4、在Unix上，该选项等同于SO_REUSEADDR；在Windows上，该选项被忽略

    QUdpSocket::DontShareAddress

    0x2

    1、采用专有的方式绑定某个地址和端口，其他任何服务都不能再重新绑定

    2、通过该选项，确保绑定成功，指定的服务将是地址和端口唯一监听者，就算是拥有ReuseAddressHint的服务也不允许重新绑定

    3、在安全性上，该选项优于ShareAddress，但是在某些操作系统上需要管理员的权限才能运行

    4、在Unix和Mac OS上，绑定地址和端口的默认行为是非共享，所以该选项会被忽略；在Windows上，等同于SO_EXCLUSIVEADDRUSE套接字选项

    QUdpSocket::ReuseAddressHint

    0x4

    1、为QUdpSocke提供提示，即在地址和端口已经被其他套接字绑定的情况下，也应该试着重新绑定

    2、在Unix上，该选项被忽略；在Windows上等同于SO_REUSEADDR 套接字选项

    QUdpSocket::DefaultForPlatform

    0x0

    1、当前平台的默认选项

    2、在Unix和Mac OS上，该选项等同于DontShareAddress + ReuseAddressHint；在Windows上等同于ShareAddress

    5.2主要程序 

    .h

    1. #ifndef MAINWINDOW_H
    2. #define MAINWINDOW_H
    3.  
    4. #include 
    5. #include 
    6. #include 
    7. #include 
    8. #include 
    9. #include 
    10. #include 
    11. #include 
    12. #include 
    13. #include 
    14. #include 
    15. #include 
    16. #include 
    17. #include 
    18.  
    19. namespace Ui {
    20.     class MainWindow;
    21. }
    22.  
    23. class MainWindow : public QMainWindow {
    24.     Q_OBJECT
    25.  
    26. public:
    27.     explicit MainWindow(QWidget* parent = 0);
    28.     ~MainWindow();
    29.  
    30. private slots:
    31.     void slotActJoinMulti();
    32.     void slotActLeaveMulti();
    33.     void slotActClearText();
    34.     void slotActQuit();
    35.     void slotSocketStateChanged(QAbstractSocket::SocketState socketState);
    36.     void slotBtnMultiMsg();
    37.     void slotReadyRead();
    38.  
    39. private:
    40.     Ui::MainWindow* ui;
    41.  
    42.     QAction* m_pActJoinMulti;
    43.     QAction* m_pActLeaveMulti;
    44.     QAction* m_pActClearText;
    45.     QAction* m_pActQuit;
    46.     QWidget* m_pCentralWidget;
    47.     QLabel* m_pLabPort;
    48.     QLabel* m_pLabAddr;
    49.     QSpinBox* m_pSpinPort;
    50.     QComboBox* m_pComboAddr;
    51.     QLineEdit* m_pLineEdit;
    52.     QPushButton* m_pBtnSendMulti;
    53.     QPlainTextEdit* m_pPlainText;
    54.     QLabel* m_pLabState;
    55.     QUdpSocket* m_pUdpSocket;
    56.     QHostAddress m_multicastAddr;
    57.  
    58.     QString getLocalIP();
    59. };
    60.  
    61. #endif  // MAINWINDOW_H

    .cpp

    1. #include "mainwindow.h"
    2.  
    3. #include "ui_mainwindow.h"
    4.  
    5. MainWindow::MainWindow(QWidget* parent) : QMainWindow(parent), ui(new Ui::MainWindow) {
    6.     ui->setupUi(this);
    7.     this->setWindowTitle(QStringLiteral("UDP Multicast"));
    8.  
    9.     //工具栏
    10.     ui->mainToolBar->setToolButtonStyle(Qt::ToolButtonTextBesideIcon);
    11.     m_pActJoinMulti = new QAction(QIcon(":/new/prefix1/res/添加群组.png"), QStringLiteral("加入组播"), this);
    12.     m_pActLeaveMulti = new QAction(QIcon(":/new/prefix1/res/退出群组.png"), QStringLiteral("退出组播"), this);
    13.     m_pActClearText = new QAction(QIcon(":/new/prefix1/res/清空.png"), QStringLiteral("清空文本"), this);
    14.     m_pActQuit = new QAction(QIcon(":/new/prefix1/res/退出.png"), QStringLiteral("退出"), this);
    15.     ui->mainToolBar->addAction(m_pActJoinMulti);
    16.     ui->mainToolBar->addAction(m_pActLeaveMulti);
    17.     ui->mainToolBar->addSeparator();
    18.     ui->mainToolBar->addAction(m_pActClearText);
    19.     ui->mainToolBar->addSeparator();
    20.     ui->mainToolBar->addAction(m_pActQuit);
    21.  
    22.     //界面布局
    23.     m_pCentralWidget = new QWidget(this);
    24.     m_pLabPort = new QLabel(QStringLiteral("组播端口"), m_pCentralWidget);
    25.     m_pSpinPort = new QSpinBox(m_pCentralWidget);
    26.     m_pSpinPort->setMinimum(1);
    27.     m_pSpinPort->setMaximum(65535);
    28.     m_pSpinPort->setValue(3200);
    29.     m_pLabAddr = new QLabel(QStringLiteral("组播地址"), m_pCentralWidget);
    30.     m_pComboAddr = new QComboBox(m_pCentralWidget);
    31.     m_pComboAddr->setEditable(true);  //下拉框可编辑输入
    32.     m_pComboAddr->addItem("239.0.0.1");
    33.     // 正则匹配 D类IP：224.0.0.0~239.255.255.255
    34.     // .必须使用转义字符\，否则.会匹配任意字符
    35.     // C++中"\"在字符串中表示要用"\\"
    36.     // 是 - 不是 ~ ； 是[0-9]不是[0~9]
    37.     QRegExp regExp("^(22[4-9]|23[0-9])(\\.((\\d)|([1-9]\\d)|(1\\d{2})|(2[0-4]\\d)|(25[0-5]))){3}$");
    38.     QValidator* pValidator = new QRegExpValidator(regExp, this);
    39.     m_pComboAddr->setValidator(pValidator);
    40.     QHBoxLayout* HLay1 = new QHBoxLayout();
    41.     HLay1->addWidget(m_pLabPort, 1, Qt::AlignRight);
    42.     HLay1->addWidget(m_pSpinPort, 1);
    43.     HLay1->addWidget(m_pLabAddr, 1, Qt::AlignRight);
    44.     HLay1->addWidget(m_pComboAddr, 2);
    45.     m_pLineEdit = new QLineEdit(m_pCentralWidget);
    46.     m_pBtnSendMulti = new QPushButton(QStringLiteral("组播消息"), m_pCentralWidget);
    47.     QHBoxLayout* HLay2 = new QHBoxLayout();
    48.     HLay2->addWidget(m_pLineEdit, 4);
    49.     HLay2->addWidget(m_pBtnSendMulti, 1);
    50.     m_pPlainText = new QPlainTextEdit(m_pCentralWidget);
    51.     QVBoxLayout* VLay = new QVBoxLayout(m_pCentralWidget);
    52.     VLay->addLayout(HLay1);
    53.     VLay->addLayout(HLay2);
    54.     VLay->addWidget(m_pPlainText);
    55.     this->setCentralWidget(m_pCentralWidget);
    56.     this->setLayout(VLay);
    57.  
    58.     //状态栏
    59.     m_pLabState = new QLabel(QStringLiteral("socket状态："), this);
    60.     m_pLabState->setMinimumWidth(150);
    61.     ui->statusBar->addWidget(m_pLabState);
    62.  
    63.     QString str = getLocalIP();
    64.     this->setWindowTitle(this->windowTitle() + "---IP:" + str);
    65.  
    66.     m_pUdpSocket = new QUdpSocket(this);
    67.     m_pUdpSocket->setSocketOption(QAbstractSocket::MulticastTtlOption, 1);
    68.  
    69.     // connect
    70.     connect(m_pActJoinMulti, &QAction::triggered, this, &MainWindow::slotActJoinMulti);
    71.     connect(m_pActLeaveMulti, &QAction::triggered, this, &MainWindow::slotActLeaveMulti);
    72.     connect(m_pActClearText, &QAction::triggered, this, &MainWindow::slotActClearText);
    73.     connect(m_pActQuit, &QAction::triggered, this, &MainWindow::slotActQuit);
    74.     connect(m_pUdpSocket, &QUdpSocket::stateChanged, this, &MainWindow::slotSocketStateChanged);
    75.     connect(m_pBtnSendMulti, &QPushButton::clicked, this, &MainWindow::slotBtnMultiMsg);
    76.     connect(m_pUdpSocket, &QUdpSocket::readyRead, this, &MainWindow::slotReadyRead);
    77. }
    78.  
    79. MainWindow::~MainWindow() { delete ui; }
    80.  
    81. void MainWindow::slotActJoinMulti() {
    82.     QString ip = m_pComboAddr->currentText();
    83.     m_multicastAddr = QHostAddress(ip);
    84.     quint16 multicastPort = m_pSpinPort->value();
    85.     if (m_pUdpSocket->bind(QHostAddress::AnyIPv4, multicastPort, QUdpSocket::ShareAddress)) {
    86.         m_pUdpSocket->joinMulticastGroup(m_multicastAddr);  //加入多播组
    87.         m_pPlainText->appendPlainText("**加入组播成功");
    88.         m_pPlainText->appendPlainText("**组播地址IP：" + ip);
    89.         m_pPlainText->appendPlainText("**绑定端口：" + QString::number(multicastPort));
    90.         m_pActJoinMulti->setEnabled(false);
    91.         m_pActLeaveMulti->setEnabled(true);
    92.         m_pComboAddr->setEditable(false);
    93.     } else {
    94.         m_pPlainText->appendPlainText("**绑定端口失败");
    95.     }
    96. }
    97.  
    98. void MainWindow::slotActLeaveMulti() {
    99.     m_pUdpSocket->leaveMulticastGroup(m_multicastAddr);  //退出组播
    100.     m_pUdpSocket->abort();                               //解除绑定
    101.     m_pActJoinMulti->setEnabled(true);
    102.     m_pActLeaveMulti->setEnabled(false);
    103.     m_pComboAddr->setEnabled(true);
    104.     m_pComboAddr->setEditable(true);
    105.     m_pPlainText->appendPlainText("**已退出组播，解除端口绑定");
    106. }
    107.  
    108. void MainWindow::slotActClearText() { m_pPlainText->clear(); }
    109.  
    110. void MainWindow::slotActQuit() {
    111.     QMessageBox::StandardButton button = QMessageBox::question(this, "", "是否退出？");
    112.     if (QMessageBox::StandardButton::Yes == button) {
    113.         this->close();
    114.     }
    115. }
    116.  
    117. void MainWindow::slotSocketStateChanged(QAbstractSocket::SocketState socketState) {
    118.     // case并不包含所有的情况，因为没有写listening的情况，所以就需要写default
    119.     switch (socketState) {
    120.         case QAbstractSocket::UnconnectedState: m_pLabState->setText("socket状态：UnconnectedState"); break;
    121.         case QAbstractSocket::HostLookupState: m_pLabState->setText("socket状态：HostLookupState"); break;
    122.         case QAbstractSocket::ConnectingState: m_pLabState->setText("socket状态：ConnectingState"); break;
    123.         case QAbstractSocket::ConnectedState: m_pLabState->setText("socket状态：ConnectedState"); break;
    124.         case QAbstractSocket::BoundState: m_pLabState->setText("socket状态：BoundState"); break;
    125.         case QAbstractSocket::ClosingState: m_pLabState->setText("socket状态：ClosingState"); break;
    126.         default: break;
    127.     }
    128. }
    129.  
    130. void MainWindow::slotBtnMultiMsg() {
    131.     QString msg = m_pLineEdit->text();
    132.     QByteArray str = msg.toUtf8();
    133.     quint16 multiPort = m_pSpinPort->value();
    134.     m_pUdpSocket->writeDatagram(str, m_multicastAddr, multiPort);
    135.     m_pPlainText->appendPlainText("[multicast] " + msg);
    136.     m_pLineEdit->clear();
    137.     m_pLineEdit->setFocus();
    138. }
    139.  
    140. void MainWindow::slotReadyRead() {
    141.     while (m_pUdpSocket->hasPendingDatagrams()) {
    142.         QByteArray dataGram;
    143.         dataGram.resize(m_pUdpSocket->pendingDatagramSize());
    144.         QHostAddress peerAddr;
    145.         quint16 peerPort;
    146.         m_pUdpSocket->readDatagram(dataGram.data(), dataGram.size(), &peerAddr, &peerPort);
    147.         QString str = dataGram.data();
    148.         QString peer = "[From " + peerAddr.toString() + ":" + QString::number(peerPort) + "] ";
    149.         m_pPlainText->appendPlainText(peer + str);
    150.         qDebug() << m_pUdpSocket->peerAddress();
    151.         qDebug() << m_pUdpSocket->localAddress().toString();
    152.         qDebug() << m_pUdpSocket->localPort();
    153.     }
    154. }
    155.  
    156. QString MainWindow::getLocalIP() {
    157.     QString localName = QHostInfo::localHostName();
    158.     QHostInfo hostInfo = QHostInfo::fromName(localName);
    159.     QList addrList = hostInfo.addresses();
    160.     QString localIP = "";
    161.     if (!addrList.isEmpty()) {
    162.         for (int i = 0; i < addrList.size(); i++) {
    163.             QHostAddress addr = addrList.at(i);
    164.             if (QAbstractSocket::IPv4Protocol == addr.protocol()) {
    165.                 localIP = addr.toString();
    166.                 break;
    167.             }
    168.         }
    169.     }
    170.     return localIP;
    171. }

    结果： 

    原文链接：https://blog.csdn.net/WL0616/article/details/129050373 

  • 相关阅读:
    React与Vue的区别
    Java中restTemplate的使用
    【Vue】Vue双向绑定原理
    [LeetCode]-138. 随机链表的复制
    iNavFlight之MSP DJI协议分析
    归纳总结笔记
    Golang学习笔记01
    MySQL场景面试，你是如何进行SQL优化的？
    六要素微气象仪
    基于微信公众平台API的菜谱小程序 的设计与实现
  • 原文地址：https://blog.csdn.net/m0_75179090/article/details/132602879