Qt5 Tutorial QUdpSocket - 2020

In this tutorial, we will learn QUdpSocket.

The most common way to use QUdpSocket class is to bind to an address and port using bind(), then call writeDatagram() and readDatagram() to transfer data. We'll do exactly that in this tutorial.

Note: Qt5 document

UDP (User Datagram Protocol) is a lightweight, unreliable, datagram-oriented, connectionless protocol.

It can be used when reliability isn't important. QUdpSocket is a subclass of QAbstractSocket that allows you to send and receive UDP datagrams.

For UDP Socket in general, please visit my C++ Tutorials: Socket - Server and Client.

We'll start with Qt Console Application.

First, we need to add network module to our project file, QUdpSocket.pro:

QT       += core
QT       += network
QT       -= gui

TARGET = QUdpSocket
CONFIG   += console
CONFIG   -= app_bundle

TEMPLATE = app


SOURCES += main.cpp

Then, we want to create a new class called MyUdpSocket.

The most common way to use QUdpSocket class is to bind to an address and port using bind(), then call writeDatagram() and readDatagram() to transfer data. We do exactly that in this tutorial.

1. In main(), we create an instance of MyUDP class:

   MyUDP client;

2. In the constructor, MyUDP::MyUDP(), a QUdpSocket will be created:

   socket = new QUdpSocket(this);

3. Then, we bind it to an address and port:

   socket->bind(QHostAddress::LocalHost, 1234);

4. In main(), we call MyUDP::HelloUDP(), and it actually sends data gram:

      socket->writeDatagram(Data, QHostAddress::LocalHost, 1234);
     

5. When the data comes in, we read that datagram in MyUDP::readyRead():

   socket->readDatagram(buffer.data(), buffer.size(),
                            &sender;, &senderPort;);

Here are the files used in this tutorial.

main.cpp:

#include <QCoreApplication>
#include "myudp.h"

int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);
    
    MyUDP client;
    
    client.HelloUDP();
    
    return a.exec();
}

myudp.h:

// myudp.h

#ifndef MYUDP_H
#define MYUDP_H

#include <QObject>
#include <QUdpSocket>

class MyUDP : public QObject
{
    Q_OBJECT
public:
    explicit MyUDP(QObject *parent = 0);
    void HelloUDP();
signals:
    
public slots:
    void readyRead();

private:
    QUdpSocket *socket;
    
};

#endif // MYUDP_H

myudp.cpp:

// myudp.cpp

#include "myudp.h"

MyUDP::MyUDP(QObject *parent) :
    QObject(parent)
{
    // create a QUDP socket
    socket = new QUdpSocket(this);
    
    // The most common way to use QUdpSocket class is 
    // to bind to an address and port using bind()
    // bool QAbstractSocket::bind(const QHostAddress & address, 
    //     quint16 port = 0, BindMode mode = DefaultForPlatform)
    socket->bind(QHostAddress::LocalHost, 1234);
    
    connect(socket, SIGNAL(readyRead()), this, SLOT(readyRead()));
}

void MyUDP::HelloUDP()
{
    QByteArray Data;
    Data.append("Hello from UDP");
    
    // Sends the datagram datagram 
    // to the host address and at port.
    // qint64 QUdpSocket::writeDatagram(const QByteArray & datagram, 
    //                      const QHostAddress & host, quint16 port)
    socket->writeDatagram(Data, QHostAddress::LocalHost, 1234);
}

void MyUDP::readyRead()
{
    // when data comes in
    QByteArray buffer;
    buffer.resize(socket->pendingDatagramSize());
    
    QHostAddress sender;
    quint16 senderPort;
    
    // qint64 QUdpSocket::readDatagram(char * data, qint64 maxSize, 
    //                 QHostAddress * address = 0, quint16 * port = 0)
    // Receives a datagram no larger than maxSize bytes and stores it in data. 
    // The sender's host address and port is stored in *address and *port 
    // (unless the pointers are 0).
    
    socket->readDatagram(buffer.data(), buffer.size(),
                         &sender;, &senderPort;);
    
    qDebug() << "Message from: " << sender.toString(); 
    qDebug() << "Message port: " << senderPort;
    qDebug() << "Message: " << buffer;
}