一、UDP单播、广播和组播的说明

UDP是不可靠、无连接的，所以划分为发送方和接收方更好理解 

1、单播

UDP是无连接的，进行单播通信时，必须要绑定接收方端口，发送方直接通过接收方的ip和绑定的端口进行通信。发送方可以绑定端口也可以不用绑定端口，不绑定端口的话，系统会随机分配端口。

对于多网卡来说，需要指定网卡，绑定一个网卡的ip。如果不进行显式的绑定操作，<code>QUdpSocket 对象将会使用默认的绑定方式，自动选择一个可用的 ip 地址进行绑定。

2、广播

对于只有1个网卡的主机来说，可以不用显示绑定ip，发送方直接发送广播就行，接收方绑定广播端口就行，这样才能看到收到的消息。 

对于多网卡来说，要指定唯一的网卡ip并且在广播前要绑定广播端口。ip可以不用绑定，这样系统会随机分配一个网卡ip。

3、组播 

对于只有1个网卡的主机来说，可以不用绑定ip，直接绑定端口后加入组播就行。系统分配任意一个ip ，相当于 QHostAddress::AnyIPv4。

对于多网卡来说，要指定唯一的网卡并且在加入组播前要绑定组播端口，ip可以不用绑定，系统分配任意一个ip。

注意：指定网卡不等于指定ip！！！ 

1、使用 setMulticastInterface 方法可以指定一个明确的网卡，但并不意味着只有一个 IP 地址。一个网卡可以绑定多个 IP 地址，例如在同一台主机上同时存在有线网卡和无线网卡，它们可能都连接到同一局域网，并分别配置了不同的 IP 地址。此时，通过 setMulticastInterface 方法指定了一个明确的网卡后，并不确定使用哪个 IP 地址来进行组播通信。

如果需要确保使用特定的 IP 地址进行组播通信，则需要使用 bind 方法来将 QUdpSocket 对象绑定到具体的 IP 地址和端口上，这样每次进行组播通信时，都会使用该 IP 地址来发送和接收数据报文。 

2、使用 QHostAddress::AnyIPv4 参数可以将 QUdpSocket 对象绑定到本机的所有 IPv4 地址。这意味着，该 QUdpSocket 对象可以接收通过本机的任意一个 IPv4 地址发送到指定端口的数据包。

然而，需要注意的是，绑定到多个 IPv4 地址并不意味着可以同时从多个地址接收数据包。在任何给定的时刻，QUdpSocket 对象只能通过一个 IP 地址接收数据包。

当有多个 IPv4 地址可用时，QUdpSocket 对象会选择其中一个地址来接收数据包。这个选择通常由操作系统或网络栈决定，并且可能会受到各种因素的影响，例如网络接口的优先级、路由表等。

因此，使用 QHostAddress::AnyIPv4 参数可以让 QUdpSocket 对象绑定到本机的所有 IPv4 地址，但实际上它只能通过其中一个地址接收数据包。具体使用哪个地址取决于操作系统和网络环境。

二、遇到的UDP通信的问题参考

      关于QT UDP组播的几个问题

https://blog.csdn.net/tom06/article/details/52163665?spm=1001.2014.3001.5506

UDP多播/组播通信，同一局域网下的两台机器通信接收不到数据

https://blog.csdn.net/qq_43290013/article/details/117288296?spm=1001.2014.3001.5506

QT读取网卡列表多网卡绑定组播网卡

https://blog.csdn.net/qq_30727593/article/details/127441711?spm=1001.2014.3001.5506

三、效果与代码

1、在.pro文件中添加如下内容：

<code>QT += network

2、在.h文件中添加串口所用的头文件

#include <QUdpSocket>

#include <QNetworkInterface>

 3、添加一个QUdpSocket* socket的类成员，并在.cpp中实例化对象：

socket = new QUdpSocket;

 4、扫描可用网口

QList<QNetworkInterface> interfaceList = QNetworkInterface::allInterfaces();

foreach (QNetworkInterface nif, interfaceList) {

// 检查网卡是否有效并已经启用

if (nif.isValid() && nif.flags().testFlag(QNetworkInterface::IsUp)) {

// 将已经启用的网卡名称添加到列表中

enabledInterfaceList.append(nif);

QList<QNetworkAddressEntry> entries = nif.addressEntries();

foreach (QNetworkAddressEntry entry, entries) {

if (entry.ip().protocol() == QAbstractSocket::IPv4Protocol) {

ui->nif_config->addItem(entry.ip().toString());

}

}

}

}

5、对组播进行设置（可以忽略）

//组播的数据的生存期，数据报没跨1个路由就会减1.表示多播数据报只能在同一路由下的局域网内传播

socket->setSocketOption(QAbstractSocket::MulticastTtlOption,1);

//1是允许loopback模式（自发自收）,0是阻止。

socket->setSocketOption(QAbstractSocket::MulticastLoopbackOption, true);

6、初始化组播设置

int MainWindow::init_group(QUdpSocket *socket, QNetworkInterface &currentInterface, QHostAddress &localAddress, QHostAddress &targetAddress, int localPort)

{

if (targetAddress.isMulticast()) {//isMulticast()判断是否是组播地址

if (localPort == 0) {//判断是否指定本地端口

//bind(localAddress, QUdpSocket::ShareAddress | QUdpSocket::ReuseAddressHint)可以换成bind(QHostAddress::AnyIPv4, QUdpSocket::ShareAddress | QUdpSocket::ReuseAddressHint)

if (socket->bind(localAddress, QUdpSocket::ShareAddress | QUdpSocket::ReuseAddressHint)) {

socket->setMulticastInterface(currentInterface);

if (socket->joinMulticastGroup(targetAddress, currentInterface)) {

qDebug() << "未指定本地端口,加入组播成功";

return 1;

} else {

qDebug() << "未指定本地端口,加入组播失败";

return -1;

}

} else {

qDebug() << "未指定本地端口,绑定失败";

return -1;

}

} else {

if (socket->bind(localAddress, localPort, QUdpSocket::ShareAddress | QUdpSocket::ReuseAddressHint)) {

socket->setMulticastInterface(currentInterface);

if (socket->joinMulticastGroup(targetAddress, currentInterface)) {

qDebug() << "指定本地端口,加入组播成功";

return 1;

} else {

qDebug() << "指定本地端口,加入组播失败";

return -1;

}

} else {

qDebug() << "指定本地端口,绑定失败";

return -1;

}

}

} else {

qDebug() << "目标地址不是组播地址";

return -1;

}

// 如果执行到这里，说明没有通过任何返回语句，应该是一个错误

qDebug() << "init_group 函数执行路径错误";

return -1; // 或者抛出异常，取决于您希望如何处理这种情况

}

1、QUdpSocket::ShareAddress： 

这个选项告诉操作系统允许多个 QUdpSocket 对象绑定到同一个地址和端口上。在默认情况下，操作系统可能会阻止多个 socket 绑定到相同的地址和端口，但是如果设置了 ShareAddress 选项，Qt 会尝试在可能的情况下共享这个地址和端口。在实际应用中，如果需要多个 QUdpSocket 对象同时监听相同的地址和端口，可以使用 ShareAddress 选项来避免绑定失败的问题。想象一下你和朋友们想在同一个电话号码上收发短信。默认情况下，操作系统可能会阻止多个程序或者多个 QUdpSocket 对象同时使用同一个网络地址（IP 地址）和端口号。但是如果你打开了 ShareAddress 选项，就像是你和朋友们一起共享一个电话号码，大家可以同时收发信息。这个选项让多个 QUdpSocket 对象可以在同一个网络地址和端口上工作，而不会相互干扰或者造成绑定失败的问题。

 2、QUdpSocket::ReuseAddressHint：

这个选项告诉操作系统允许在 UDP Socket 关闭之后，立即重新使用相同的地址和端口。如果没有设置这个选项，操作系统会在 QUdpSocket 关闭后一段时间内保持端口的占用状态，这可能会导致稍后尝试重新绑定失败。设置 ReuseAddressHint 可以避免在关闭一个 QUdpSocket 后立即重新绑定时遇到 Address already in use 的错误。想象一下你用一个电话号码打电话，然后挂了电话。在一段时间内，电话号码可能会被暂时保留，不允许其他人再用。这就好比默认情况下，当一个 QUdpSocket 关闭后，操作系统可能会暂时保留使用的网络地址和端口号，不让其他程序立即使用。如果你设置了 ReuseAddressHint，就像是告诉操作系统，“我关掉电话后，如果其他人想用这个电话号码，可以立刻用，不用等。” 这个选项允许在一个 QUdpSocket 关闭后，立即重新使用相同的网络地址和端口号，而不会遇到“地址已经被占用”的错误。

总结：使用后可以重复ip和端口

7、发送消息

socket->writeDatagram(str,targetAddress,targetPort);

8、接收消息

//接收消息

connect(udpSocket,&QUdpSocket::readyRead,this,[&](){

QByteArray datagram;

datagram.resize(udpSocket->pendingDatagramSize());

udpSocket->readDatagram(datagram.data(), datagram.size());

ui->recvTextEdit->append(datagram);

});

9、退出组播

int MainWindow::exit_group(QUdpSocket *socket ,QNetworkInterface &currentInterface, QHostAddress &targetAddress)

{

if(socket->leaveMulticastGroup(targetAddress，currentInterface)){

socket->abort();

qDebug() << "退出组播成功";

return 1;

}else{

qDebug() << "退出组播失败";

return -1;

}

}

四、自定义UDP工具类

MyUdpTools.h 

#ifndef MYUDPTOOLS_H

#define MYUDPTOOLS_H

#include <QObject>

#include <QThread>

#include <QComboBox>

#include <QUdpSocket>

#include <QMessageBox>

#include <QApplication>

#include <QNetworkDatagram>

#include <QNetworkInterface>

class MyUdpTools : public QObject

{

Q_OBJECT

public:

explicit MyUdpTools(QObject *parent = nullptr);

~MyUdpTools();

// 单播相关方法

int setupUnicast(QString currentNetInterfacrAddress, quint16 port = 0);

void sendUnicastData(QString targetAddress,quint16 port,const QByteArray &data);

int exitUnicast();

// 组播相关方法

int setupMulticast(QNetworkInterface *netInterface,QString currentNetInterfacrAddress,QString groupAddress, quint16 port = 0);

void sendMulticastData(QString targetAddress,quint16 port,const QByteArray &data);

int exitMulticast();

// 广播相关方法

int setupBroadcast(QString currentNetInterfacrAddress,QString targetAddress,quint16 port = 0);

void sendBroadcastData(QString targetAddress,quint16 port,const QByteArray &data);

int exitBroadcast();

//添加或刷新combox的网卡信息

void init_or_flash_NetInterfaceInfoToCombox(QList<QNetworkInterface> &list,QComboBox *combox);

signals:

void sig_RecvData(QByteArray data);

private slots:

void processPendingDatagrams();//接收数据槽函数

void handleSocketError(QAbstractSocket::SocketError socketError);//Udp错误日志

private:

QThread *thread;

QHostAddress localAddress;//本机当前网卡ip

QUdpSocket *unicastSocket;//单播

quint16 unicastPort_Local;//单播本地端口

quint16 unicastPort_Target;//单播目标端口

QHostAddress targetAddress_Unicast;//单播目标地址

QUdpSocket *multicastSocket;//组播

QHostAddress multicastGroupAddress;//组播地址

quint16 multicastPort_Local;//组播本地端口

quint16 multicastPort_Target;//组播目标端口

QUdpSocket *broadcastSocket;//广播

QHostAddress broadcastGroupAddress;//广播地址

quint16 broadcastPort_Local;//广播本地端口

quint16 broadcastPort_Target;//广播目标端口

};

#endif // MYUDPTOOLS_H

MyUdpTools.cpp

#include "myudptools.h"

MyUdpTools::MyUdpTools(QObject *parent)

: QObject(parent),unicastSocket(nullptr),multicastSocket(nullptr),broadcastSocket(nullptr)

{

thread = new QThread();

moveToThread(thread);

//应用程序关闭后触发

connect(qApp,&QApplication::aboutToQuit,thread, &QThread::quit);

//线程退出后触发

connect(thread, &QThread::finished, thread, &QThread::deleteLater);

connect(thread,&QThread::finished,this,&MyUdpTools::deleteLater);

// 在子线程中直接调用函数

QMetaObject::invokeMethod(this, "init_or_flash_NetInterfaceInfoToCombox", Qt::QueuedConnection);

//启动线程

thread->start();

}

MyUdpTools::~MyUdpTools()

{

if(unicastSocket){

delete unicastSocket;

}

if(multicastSocket){

delete multicastSocket;

}

if(broadcastSocket){

delete broadcastSocket;

}

}

//===========================单播相关方法实现===========================

int MyUdpTools::setupUnicast(QString currentNetInterfacrAddress, quint16 port)

{

if (!unicastSocket) {

unicastSocket = new QUdpSocket(this);//将父对象设置为当前对象

connect(unicastSocket, &QUdpSocket::readyRead, this, &MyUdpTools::processPendingDatagrams);

connect(unicastSocket, SIGNAL(error(QAbstractSocket::SocketError)),this, SLOT(handleSocketError(QAbstractSocket::SocketError)));

qInfo() << "创建单播socket";

}

localAddress = QHostAddress(currentNetInterfacrAddress);

unicastPort_Local = port;

if(port == 0){

if (!unicastSocket->bind(localAddress,QUdpSocket::ReuseAddressHint|QUdpSocket::ShareAddress)) {

qCritical() << "单播绑定失败:" << unicastSocket->errorString();

return -1;

}

}else{

if (!unicastSocket->bind(localAddress, unicastPort_Local,QUdpSocket::ReuseAddressHint|QUdpSocket::ShareAddress)) {

qCritical() << "单播绑定失败:" << unicastSocket->errorString();

return -1;

}

}

qInfo() << "单播连接成功";

return 1;

}

void MyUdpTools::sendUnicastData(QString targetAddress, quint16 port, const QByteArray &data)

{

if(unicastSocket){

targetAddress_Unicast = QHostAddress(targetAddress);

unicastPort_Target = port;

if(unicastSocket->writeDatagram(data,targetAddress_Unicast,unicastPort_Target) == -1){

qCritical() << "发送单播数据失败:" << unicastSocket->errorString();

}

}

}

int MyUdpTools::exitUnicast()

{

if (unicastSocket) {

unicastSocket->close();

qCritical() << "退出成功";

return 1;

}else{

qCritical() << "已退出单播，无需再退出";

return -1;

}

}

//===========================组播相关方法实现===========================

int MyUdpTools::setupMulticast(QNetworkInterface *netInterface,QString currentNetInterfacrAddress, QString groupAddress, quint16 port)

{

if(!multicastSocket){

multicastSocket = new QUdpSocket(this);

connect(multicastSocket, &QUdpSocket::readyRead, this, &MyUdpTools::processPendingDatagrams);

connect(multicastSocket, SIGNAL(error(QAbstractSocket::SocketError)),this, SLOT(handleSocketError(QAbstractSocket::SocketError)));

qInfo() << "创建组播socket";

}

localAddress = QHostAddress(currentNetInterfacrAddress);

multicastGroupAddress = QHostAddress(groupAddress);

multicastPort_Local = port;

if(!multicastGroupAddress.isMulticast()){

qWarning() << "不是组播地址";

return -1;

}

if(port == 0){

if(!multicastSocket->bind(localAddress,QUdpSocket::ReuseAddressHint|QUdpSocket::ShareAddress)){

qCritical() << "组播绑定失败:" << multicastSocket->errorString();

return -1;

}

}else{

if(!multicastSocket->bind(localAddress,multicastPort_Local,QUdpSocket::ReuseAddressHint|QUdpSocket::ShareAddress)){

qCritical() << "组播绑定失败:" << multicastSocket->errorString();

return -1;

}

}

multicastSocket->setMulticastInterface(*netInterface);

if(!multicastSocket->joinMulticastGroup(multicastGroupAddress,*netInterface)){

qCritical() << "加入组播失败:" << multicastSocket->errorString();

return -1;

}

qInfo() << "组播连接成功";

return 1;

}

void MyUdpTools::sendMulticastData(QString targetAddress, quint16 port, const QByteArray &data)

{

if(multicastSocket){

multicastGroupAddress = QHostAddress(targetAddress);

multicastPort_Target = port;

if(multicastSocket->writeDatagram(data,multicastGroupAddress,multicastPort_Target) == -1){

qCritical() << "发送组播数据失败:" << multicastSocket->errorString();

}

}

}

int MyUdpTools::exitMulticast()

{

if (multicastSocket) {

multicastSocket->leaveMulticastGroup(multicastGroupAddress);

multicastSocket->close();

qInfo() << "退出组播成功";

return 1;

}else{

qCritical() << "已退出组播,无需再退出";

return -1;

}

}

//===========================广播相关方法实现===========================

int MyUdpTools::setupBroadcast(QString currentNetInterfaceAddress,QString targetAddress, quint16 port)

{

if (!broadcastSocket) {

broadcastSocket = new QUdpSocket(this);//将父对象设置为当前对象

connect(broadcastSocket, &QUdpSocket::readyRead, this, &MyUdpTools::processPendingDatagrams);

connect(broadcastSocket, SIGNAL(error(QAbstractSocket::SocketError)),this, SLOT(handleSocketError(QAbstractSocket::SocketError)));

qInfo() << "创建广播socket";

}

localAddress = QHostAddress(currentNetInterfaceAddress);

broadcastPort_Local = port;

broadcastGroupAddress = QHostAddress(targetAddress);

if(!broadcastGroupAddress.isBroadcast()){

qCritical() << "不是广播地址";

return -1;

}

if(port == 0){

if (!broadcastSocket->bind(localAddress,QUdpSocket::ReuseAddressHint|QUdpSocket::ShareAddress)) {

qCritical() << "广播绑定失败:" << broadcastSocket->errorString();

return -1;

}

}else{

if (!broadcastSocket->bind(localAddress, broadcastPort_Local,QUdpSocket::ReuseAddressHint|QUdpSocket::ShareAddress)) {

qCritical() << "广播绑定失败:" << broadcastSocket->errorString();

return -1;

}

}

qInfo() << "连接成功";

return 1;

}

void MyUdpTools::sendBroadcastData(QString targetAddress, quint16 port, const QByteArray &data)

{

if(broadcastSocket){

broadcastGroupAddress = QHostAddress(targetAddress);

broadcastPort_Target = port;

if(broadcastSocket->writeDatagram(data,broadcastGroupAddress,broadcastPort_Target) == -1){

qCritical() << "发送广播数据失败:" << broadcastSocket->errorString();

}

}

}

int MyUdpTools::exitBroadcast()

{

if (broadcastSocket) {

broadcastSocket->close();

qInfo() << "退出成功";

return 1;

}else{

qDebug() << "已退出广播,无需再退出";

return -1;

}

}

//===========================添加或刷新combox的网卡信息函数实现===========================

void MyUdpTools::init_or_flash_NetInterfaceInfoToCombox(QList<QNetworkInterface> &list, QComboBox *combox)

{

list.clear();

combox->clear();

QList<QNetworkInterface> interfaceList = QNetworkInterface::allInterfaces();

foreach (QNetworkInterface nif, interfaceList) {

// 检查网卡是否有效并已经启用

if (nif.isValid() && nif.flags().testFlag(QNetworkInterface::IsUp)) {

// 将已经启用的网卡名称添加到列表中

list.append(nif);

QList<QNetworkAddressEntry> entries = nif.addressEntries();

foreach (QNetworkAddressEntry entry, entries) {

if (entry.ip().protocol() == QAbstractSocket::IPv4Protocol) {

combox->addItem(entry.ip().toString());

}

}

}

}

}

//===========================接收数据槽函数实现===========================

void MyUdpTools::processPendingDatagrams()

{

QUdpSocket *socket = qobject_cast<QUdpSocket *>(sender());//sender()发送信号的对象的指针

if (!socket) return;

while (socket->hasPendingDatagrams()) {

#if 1

QByteArray datagram;

datagram.resize(socket->pendingDatagramSize());

socket->readDatagram(datagram.data(), datagram.size());

qDebug() << "Received Data:" << datagram;

emit sig_RecvData(datagram);

#else

QNetworkDatagram datagram = socket->receiveDatagram();

QByteArray data = datagram.data();

emit sig_RecvData(data);

#endif

}

}

//===========================Udp错误日志信息===========================

void MyUdpTools::handleSocketError(QAbstractSocket::SocketError socketError)

{

QUdpSocket *socket = qobject_cast<QUdpSocket *>(sender());

if (!socket) return;

switch (socketError) {

case QAbstractSocket::HostNotFoundError:

qCritical() << "Host not found error:" << socket->errorString();

break;

case QAbstractSocket::ConnectionRefusedError:

qCritical() << "Connection refused error:" << socket->errorString();

break;

case QAbstractSocket::DatagramTooLargeError:

qCritical() << "Datagram too large error:" << socket->errorString();

break;

default:

qCritical() << "Socket error:" << socket->errorString();

break;

}

}

注意：

为什么new QThread();不能指定父对象为this？

如果指定父对象为this的话， QThread 的生命周期就由其父对象MyUdpTools管理，不是由QThread直接管理，这不是推荐的做法。

不同线程之间的通信要用信号与槽进行通信。

在子线程中不能调用函数，会影响线程安全，可以在主线程中使用函数QMetaObject::invokeMethod 使得 子线程能直接调用函数。