【Qt入門】QAbstractSocket::bind()を使ったUDP/TCPソケットプログラミング例

2025-05-27

QAbstractSocket::bind()は、Qtのネットワークモジュールで提供される、ソケットを特定のアドレスとポートに**関連付ける（バインドする）**ための関数です。

ネットワークプログラミングにおいて、ソケットがデータの送受信を開始する前に、自身の「住所」と「電話番号」を設定するようなものです。

主な目的

この関数は主に以下の目的で使用されます。

サーバーソケットの準備
サーバーアプリケーション（例：Webサーバーやチャットサーバー）は、クライアントからの接続要求を受け入れるために、特定のポートでリッスンする必要があります。bind()を使うことで、そのソケットがどのネットワークインターフェース（IPアドレス）のどのポートで接続を待つかを指定します。
UDPソケットの準備
UDP（User Datagram Protocol）通信では、データの送受信を行う前に、そのソケットがどのポートからデータグラム（パケット）を送受信するかをbind()で指定することが一般的です。

関数のシグネチャ

QAbstractSocketにはいくつかのbind()のオーバーロードがありますが、代表的なものは以下の通りです。

bool QAbstractSocket::bind(const QHostAddress &address, quint16 port = 0, QAbstractSocket::BindMode mode = QAbstractSocket::DefaultForPlatform)
bool QAbstractSocket::bind(quint16 port = 0, QAbstractSocket::BindMode mode = QAbstractSocket::DefaultForPlatform)

戻り値: バインドが成功した場合はtrueを、失敗した場合はfalseを返します。失敗した場合、error()関数で詳細なエラー情報を取得できます。
mode: バインドの振る舞いを制御するためのオプションを指定します。例えば、QAbstractSocket::ShareAddressは、同じアドレスとポートを複数のソケットで共有することを許可します。
port: ソケットをバインドするポート番号を指定します。0を指定すると、システムが利用可能なポートを自動的に割り当てます。
address: ソケットをバインドするIPアドレスを指定します。QHostAddress::Anyを指定すると、利用可能なすべてのネットワークインターフェースでリッスンします。

具体的な使用例

サーバーソケットの例 (QTcpServer と合わせて使用する場合)

通常、QTcpServerを使用する場合、内部でbind()を呼び出すため、明示的にQTcpSocketに対してbind()を呼び出すことはあまりありません。しかし、特定のIPアドレスでリッスンしたい場合は、QTcpServer::listen()の引数として指定できます。

UDPソケットの例 (QUdpSocket)

#include <QUdpSocket>
#include <QHostAddress>
#include <QDebug>

int main() {
    QUdpSocket udpSocket;

    // ポート12345にバインド
    if (udpSocket.bind(QHostAddress::Any, 12345)) {
        qDebug() << "UDPソケットがポート12345にバインドされました。";
    } else {
        qDebug() << "UDPソケットのバインドに失敗しました:" << udpSocket.errorString();
    }

    // ... その後、データの送受信を行う ...

    return 0;
}

この例では、QUdpSocketがQHostAddress::Any（どのIPアドレスでも）の12345番ポートでデータグラムの送受信を待つように設定されます。

注意点

戻り値の確認
bind()の戻り値を必ず確認し、失敗した場合は適切なエラー処理を行うことが重要です。
特権ポート
1024未満のポート番号は「特権ポート」と呼ばれ、LinuxなどのOSでは通常、root権限がないとバインドできません。
ポートの可用性
指定したポートがすでに他のアプリケーションによって使用されている場合、bind()は失敗します。

QAbstractSocket::bind()は、ソケットを特定のアドレスとポートに割り当てるために使用される重要な関数ですが、様々な理由で失敗することがあります。関数がfalseを返した場合、QAbstractSocket::error()およびQAbstractSocket::errorString()を使って具体的なエラー情報を取得し、原因を特定することがトラブルシューティングの第一歩となります。

QAbstractSocket::AddressInUseError (アドレスが既に使用中)

トラブルシューティング:
1. ポート番号の変更: テスト中であれば、使用されていない可能性のある別のポート番号を試します。
2. 既存のプロセスを確認: そのポートを使用している可能性のある他のアプリケーション（以前に起動した自身のアプリケーションのインスタンスなど）が実行されていないか確認し、終了させます。
  - Linux/macOS: netstat -tulnp | grep <ポート番号> または lsof -i :<ポート番号>
  - Windows: netstat -ano | findstr :<ポート番号> と tasklist | findstr <PID>
3. SO_REUSEADDRオプションの使用: QAbstractSocket::ShareAddressモードを使用することで、通常はTIME_WAIT状態のポートをすぐに再利用できます。これは特に開発中に頻繁にアプリケーションを起動・終了する場合に役立ちます。
```
// QUdpSocketの例
QUdpSocket udpSocket;
if (!udpSocket.bind(QHostAddress::Any, 12345, QUdpSocket::ShareAddress)) {
    qDebug() << "バインド失敗:" << udpSocket.errorString();
}
```
  ただし、ShareAddressは複数のソケットが同じポートにバインドすることを許可するため、意図しないデータ受信につながる可能性もあるため注意が必要です。サーバー用途で同じアドレスとポートを複数のプロセスで共有したい場合は、QAbstractSocket::ReuseAddressHintやQAbstractSocket::ReuseAddressAndPortHintなども検討しますが、これらはOSのサポートに依存します。
考えられる原因:
- 指定されたIPアドレスとポート番号の組み合わせが、既にシステム上の別のプロセス（または同じアプリケーションの別のソケット）によって使用されている場合。
- 以前にアプリケーションが異常終了し、ソケットが適切にクローズされなかったために、OSがそのポートをすぐに再利用可能にしない場合（TIME_WAIT状態など）。
エラーコード: QAbstractSocket::AddressInUseError

QAbstractSocket::SocketAccessError (ソケットアクセス権限のエラー)

トラブルシューティング:
1. ポート番号の変更: 1024以上のポート番号を使用します。一般的なアプリケーションでは、通常こちらのポート範囲を使用します。
2. 管理者権限での実行: テスト目的などでどうしても特権ポートを使用する必要がある場合は、アプリケーションを管理者（Windows）またはroot（Linux/macOS）権限で実行します。ただし、これはセキュリティ上のリスクを伴うため、本番環境での推奨はされません。
考えられる原因:
- 1024未満のポート番号（特権ポート）にバインドしようとしているが、アプリケーションがそのための十分な権限（root/管理者権限）を持っていない場合。
エラーコード: QAbstractSocket::SocketAccessError

QAbstractSocket::SocketAddressNotAvailableError (指定されたアドレスが利用不可)

トラブルシューティング:
1. IPアドレスの確認: 指定したIPアドレスが、実際にそのマシンのネットワークインターフェースに割り当てられている有効なIPアドレスであることを確認します。
  - QHostAddress::LocalHost (127.0.0.1) や QHostAddress::Any を使って試してみると、アドレス自体の問題かを切り分けられます。
2. ネットワーク設定の確認: マシンのネットワーク設定を確認し、IPアドレスが正しく設定されているか、必要なネットワークインターフェースが有効になっているかを確認します。
考えられる原因:
- 指定されたIPアドレス（例: 192.168.1.100）が、そのマシンに存在しないネットワークインターフェースのものである場合。
- IPv6アドレスを指定したが、システムがIPv6をサポートしていない、または無効になっている場合。
エラーコード: QAbstractSocket::SocketAddressNotAvailableError

QAbstractSocket::NetworkError (一般的なネットワークエラー)

トラブルシューティング:
1. ネットワーク接続の確認: ネットワークケーブルが正しく接続されているか、Wi-Fiが有効になっているかを確認します。
2. ファイアウォールの確認: OSのファイアウォール（Windows Defender Firewall, iptables/ufwなど）やサードパーティのセキュリティソフトウェアが、アプリケーションのネットワークアクセスをブロックしていないか確認します。必要に応じて、例外を追加するか、一時的に無効にしてテストします。
3. 他のネットワークアプリケーションの動作確認: 他のネットワークを使用するアプリケーション（ウェブブラウザなど）が正常に動作するか確認し、システム全体のネットワーク問題でないかを切り分けます。
考えられる原因:
- 一般的なネットワークアダプターの問題（ケーブルが抜けている、Wi-Fiが切断されているなど）。
- ファイアウォールやセキュリティソフトウェアがソケットの作成やバインドをブロックしている。
エラーコード: QAbstractSocket::NetworkError

QAbstractSocket::UnsupportedSocketOperationError (サポートされていないソケット操作)

トラブルシューティング:
1. BindModeの確認: 使用しているBindModeがOSでサポートされているか確認します。通常はQAbstractSocket::DefaultForPlatformを使用するのが最も安全です。
考えられる原因:
- 指定されたBindModeが、実行中のOSでサポートされていない場合。
- まれに、ソケットの種類（TCP/UDP）に対してサポートされていない操作を行おうとした場合。
エラーコード: QAbstractSocket::UnsupportedSocketOperationError

タイミングの問題: マルチスレッドアプリケーションでソケット操作を行う場合、スレッド間の同期が不十分だと、ソケットの状態が予期せず変わったり、競合状態が発生したりする可能性があります。Qtのネットワーククラスは通常、イベントループ内で動作するように設計されており、異なるスレッドから直接ソケットを操作するのではなく、QObject::moveToThread()などを利用してシグナルとスロットで連携させるのが安全です。
モジュールの追加: Qtのネットワーク機能を使用するには、.proファイルにQT += networkを追加する必要があります。これが欠けていると、リンクエラーが発生する可能性があります。
QTcpServerとbind(): QTcpServerを使用する場合、通常はlisten()関数を呼び出す際に内部的にbind()が実行されます。QTcpSocket単体でサーバーのように振る舞わせる（特定のポートでリッスンする）ことは一般的ではありません。bind()は主にQUdpSocketや、より低レベルなソケット操作を行う場合に直接呼び出されます。
エラーハンドリングの徹底: bind()がfalseを返した場合、必ずqDebug() << socket->errorString();のようにして、エラーメッセージを出力し、原因を特定できるようにします。

QTcpServerを使用する一般的なTCPサーバーのケースでは、QTcpServer::listen()関数が内部でソケットのバインドとリッスンを行うため、通常はQTcpSocketオブジェクトに対して直接bind()を呼び出すことはありません。

ここでは、それぞれのシナリオでのbind()の使用例を説明します。

例1: UDPサーバー（データグラム受信）

QUdpSocketを使って特定のポートにバインドし、クライアントからのUDPデータグラムを受信する最も一般的な例です。

myudpserver.h

#ifndef MYUDPSERVER_H
#define MYUDPSERVER_H

#include <QObject>
#include <QUdpSocket>
#include <QHostAddress>

class MyUdpServer : public QObject
{
    Q_OBJECT
public:
    explicit MyUdpServer(QObject *parent = nullptr);

signals:

public slots:
    void readyRead(); // データが受信されたときに呼ばれるスロット

private:
    QUdpSocket *udpSocket;
    quint16 serverPort = 12345; // 使用するポート番号
};

#endif // MYUDPSERVER_H

myudpserver.cpp

#include "myudpserver.h"
#include <QDebug>
#include <QNetworkDatagram> // Qt 5.7以降で推奨

MyUdpServer::MyUdpServer(QObject *parent)
    : QObject(parent)
{
    udpSocket = new QUdpSocket(this);

    // UDPソケットを特定のIPアドレス（ここではAny、つまり全ての利用可能なインターフェース）とポートにバインド
    if (udpSocket->bind(QHostAddress::Any, serverPort)) {
        qDebug() << "UDPソケットがポート" << serverPort << "に正常にバインドされました。";
        // データが受信可能になったらreadyReadスロットを呼び出す
        connect(udpSocket, &QUdpSocket::readyRead, this, &MyUdpServer::readyRead);
    } else {
        qCritical() << "UDPソケットのバインドに失敗しました:" << udpSocket->errorString();
        // エラーが発生した場合、アプリケーションを終了するか、再試行するなどの処理を検討
    }
}

void MyUdpServer::readyRead()
{
    while (udpSocket->hasPendingDatagrams()) {
        QNetworkDatagram datagram = udpSocket->receiveDatagram();
        QByteArray data = datagram.data();
        QHostAddress senderAddress = datagram.senderAddress();
        quint16 senderPort = datagram.senderPort();

        qDebug() << "データ受信元:" << senderAddress.toString() << ":" << senderPort;
        qDebug() << "受信データ:" << data.constData();

        // 受信したデータに返信することも可能
        // udpSocket->writeDatagram("Hello from server!", senderAddress, senderPort);
    }
}

main.cpp

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

int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);

    MyUdpServer server;

    return a.exec();
}

プロジェクトファイル (.pro)

QT += core network

SOURCES += \
    main.cpp \
    myudpserver.cpp

HEADERS += \
    myudpserver.h

動作確認
このプログラムを実行し、別のUDPクライアント（例: Pythonのsocketモジュールやnetcat -uコマンド）からlocalhost:12345へメッセージを送ると、サーバー側で受信したメッセージが表示されます。

例2: TCPクライアントで特定のローカルIPアドレスから接続を開始する

通常、TCPクライアント（QTcpSocket）はconnectToHost()を呼び出すだけで、OSが自動的に適切なローカルIPアドレスとポートを割り当てます。しかし、特定のネットワークインターフェース（例: 複数のNICを持つサーバーで、特定のNICから接続を開始したい場合）から接続を開始したい場合は、connectToHost()を呼び出す前にbind()を使用できます。

myclient.h

#ifndef MYCLIENT_H
#define MYCLIENT_H

#include <QObject>
#include <QTcpSocket>
#include <QHostAddress>

class MyClient : public QObject
{
    Q_OBJECT
public:
    explicit MyClient(QObject *parent = nullptr);

signals:

public slots:
    void connected();
    void disconnected();
    void readyRead();
    void socketError(QAbstractSocket::SocketError error);

private:
    QTcpSocket *tcpSocket;
};

#endif // MYCLIENT_H

myclient.cpp

#include "myclient.h"
#include <QDebug>

MyClient::MyClient(QObject *parent)
    : QObject(parent)
{
    tcpSocket = new QTcpSocket(this);

    connect(tcpSocket, &QTcpSocket::connected, this, &MyClient::connected);
    connect(tcpSocket, &QTcpSocket::disconnected, this, &MyClient::disconnected);
    connect(tcpSocket, &QTcpSocket::readyRead, this, &MyClient::readyRead);
    connect(tcpSocket, QOverload<QAbstractSocket::SocketError>::of(&QTcpSocket::error),
            this, &MyClient::socketError);

    // バインドするローカルIPアドレスを指定（例: "192.168.1.10"）
    // このIPアドレスがローカルマシンに存在しないとバインドに失敗します。
    // QHostAddress::AnyIPv4 や QHostAddress::LocalHost を試すと切り分けに便利です。
    QHostAddress localBindAddress("192.168.1.10"); // ← ここを自身の環境のローカルIPアドレスに設定
    quint16 localBindPort = 0; // 0を指定するとOSが利用可能なポートを自動的に割り当てます

    if (tcpSocket->bind(localBindAddress, localBindPort)) {
        qDebug() << "TCPソケットがローカルアドレス" << localBindAddress.toString()
                 << "ポート" << tcpSocket->localPort() << "にバインドされました。";

        // バインド後、リモートホストに接続
        // ここでは適当なリモートサーバー（例: Google DNS）を指定
        tcpSocket->connectToHost("8.8.8.8", 53); // リモートホストとポート
    } else {
        qCritical() << "TCPソケットのバインドに失敗しました:" << tcpSocket->errorString();
    }
}

void MyClient::connected()
{
    qDebug() << "サーバーに接続しました！";
    qDebug() << "ローカルアドレス:" << tcpSocket->localAddress().toString()
             << ", ローカルポート:" << tcpSocket->localPort();
    qDebug() << "ピアアドレス:" << tcpSocket->peerAddress().toString()
             << ", ピアポート:" << tcpSocket->peerPort();

    tcpSocket->write("Hello from Qt Client!");
}

void MyClient::disconnected()
{
    qDebug() << "サーバーから切断されました。";
}

void MyClient::readyRead()
{
    QByteArray data = tcpSocket->readAll();
    qDebug() << "サーバーからのデータ受信:" << data;
}

void MyClient::socketError(QAbstractSocket::SocketError error)
{
    Q_UNUSED(error);
    qCritical() << "ソケットエラー:" << tcpSocket->errorString();
}

main.cpp

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

int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);

    MyClient client;

    return a.exec();
}

プロジェクトファイル (.pro)

QT += core network

SOURCES += \
    main.cpp \
    myclient.cpp

HEADERS += \
    myclient.h

重要な注意点

この例では、QTcpSocketがデータを送信し、受信するまでの処理は非常に簡略化されています。実際のアプリケーションでは、より複雑なプロトコル処理が必要になります。
localBindAddressには、実際にそのマシンに存在するIPアドレスを指定してください。存在しないIPアドレスを指定するとbind()はSocketAddressNotAvailableErrorで失敗します。

例3: `QTcpServer`によるサーバー構築（`bind()`の暗黙的呼び出し）

これはQTcpServerを使用する最も一般的な方法であり、bind()を明示的に呼び出す必要がないことを示しています。listen()が内部でバインド処理を行います。

mytcpserver.h

#ifndef MYTCPSERVER_H
#define MYTCPSERVER_H

#include <QObject>
#include <QTcpServer>
#include <QTcpSocket>
#include <QHostAddress>

class MyTcpServer : public QObject
{
    Q_OBJECT
public:
    explicit MyTcpServer(QObject *parent = nullptr);
    ~MyTcpServer();

signals:

public slots:
    void newConnection();
    void readyRead();
    void disconnected();
    void socketError(QAbstractSocket::SocketError error);

private:
    QTcpServer *tcpServer;
    QList<QTcpSocket*> clientSockets; // 接続されたクライアントソケットのリスト
    quint16 serverPort = 54321; // 使用するポート番号
};

#endif // MYTCPSERVER_H

mytcpserver.cpp

#include "mytcpserver.h"
#include <QDebug>

MyTcpServer::MyTcpServer(QObject *parent)
    : QObject(parent)
{
    tcpServer = new QTcpServer(this);

    // 新しい接続があったときにnewConnectionスロットを呼び出す
    connect(tcpServer, &QTcpServer::newConnection, this, &MyTcpServer::newConnection);

    // サーバーを特定のIPアドレス（Any）とポートに設定し、リッスンを開始
    // listen()が内部でQAbstractSocket::bind()を呼び出す
    if (tcpServer->listen(QHostAddress::Any, serverPort)) {
        qDebug() << "TCPサーバーがポート" << serverPort << "でリッスンを開始しました。";
        qDebug() << "ローカルアドレス:" << tcpServer->serverAddress().toString()
                 << ", ローカルポート:" << tcpServer->serverPort();
    } else {
        qCritical() << "TCPサーバーのリッスンに失敗しました:" << tcpServer->errorString();
    }
}

MyTcpServer::~MyTcpServer()
{
    // クライアントソケットをクローズし、サーバーを停止
    qDeleteAll(clientSockets);
    tcpServer->close();
}

void MyTcpServer::newConnection()
{
    qDebug() << "新しい接続がありました！";

    QTcpSocket *clientSocket = tcpServer->nextPendingConnection();
    if (clientSocket) {
        clientSockets.append(clientSocket);
        qDebug() << "接続元:" << clientSocket->peerAddress().toString()
                 << ":" << clientSocket->peerPort();

        // クライアントソケットからのデータ受信と切断シグナルを接続
        connect(clientSocket, &QTcpSocket::readyRead, this, &MyTcpServer::readyRead);
        connect(clientSocket, &QTcpSocket::disconnected, this, &MyTcpServer::disconnected);
        connect(clientSocket, QOverload<QAbstractSocket::SocketError>::of(&QTcpSocket::error),
                this, &MyTcpServer::socketError);
    }
}

void MyTcpServer::readyRead()
{
    QTcpSocket *senderSocket = qobject_cast<QTcpSocket*>(sender());
    if (senderSocket) {
        QByteArray data = senderSocket->readAll();
        qDebug() << "クライアントからのデータ受信:" << data;

        // 受信したデータをそのままクライアントにエコーバック
        senderSocket->write("Server received: " + data);
    }
}

void MyTcpServer::disconnected()
{
    QTcpSocket *senderSocket = qobject_cast<QTcpSocket*>(sender());
    if (senderSocket) {
        qDebug() << "クライアントが切断しました:"
                 << senderSocket->peerAddress().toString()
                 << ":" << senderSocket->peerPort();
        clientSockets.removeAll(senderSocket);
        senderSocket->deleteLater(); // ソケットを安全に削除
    }
}

void MyTcpServer::socketError(QAbstractSocket::SocketError error)
{
    QTcpSocket *senderSocket = qobject_cast<QTcpSocket*>(sender());
    if (senderSocket) {
        Q_UNUSED(error);
        qCritical() << "クライアントソケットエラー:" << senderSocket->errorString();
    }
}

main.cpp

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

int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);

    MyTcpServer server;

    return a.exec();
}

プロジェクトファイル (.pro)

QT += core network

SOURCES += \
    main.cpp \
    mytcpserver.cpp

HEADERS += \
    mytcpserver.h

動作確認
このプログラムを実行し、別のTCPクライアント（例: telnet localhost 54321 や netcat localhost 54321、または別のQt QTcpSocketクライアント）から接続すると、サーバー側で接続とデータ受信がログに表示されます。

QTcpServer::listen() を使用する（TCPサーバーの場合）

最も一般的な代替方法です。TCPサーバーを作成する場合、QTcpServer クラスを使用するのが標準的です。QTcpServer::listen() 関数は、指定されたアドレスとポートで incoming connections（受信接続）をリッスンするようソケットを準備します。この関数は内部で QAbstractSocket::bind() と同等の処理（ソケットの作成、アドレスとポートへのバインド）を行います。

利点

通常、bind() が失敗する原因となる AddressInUseError などのエラーハンドリングが、listen() の戻り値や errorString() で行えます。
ノンブロッキングな設計で、Qt のイベントループとシグナル・スロットメカニズムとシームレスに統合されます。
サーバーの構築が非常に簡単で、自動的に接続の受け入れ、クライアントソケットの管理が行われます。

使用例

#include <QTcpServer>
#include <QHostAddress>
#include <QDebug>

// MyTcpServerクラス（詳細な実装は省略。前回の説明の例3を参照）
// class MyTcpServer : public QObject { ... };

int main(int argc, char *argv[]) {
    QCoreApplication a(argc, argv);

    QTcpServer server;
    quint16 port = 12345;

    // QTcpServer::listen() を使うと、内部でbind()が行われる
    if (server.listen(QHostAddress::Any, port)) {
        qDebug() << "TCPサーバーがポート" << port << "でリッスンを開始しました。";
        // 新しい接続があった場合のシグナルとスロットを接続
        // QObject::connect(&server, &QTcpServer::newConnection, &myServerObject, &MyServerObject::handleNewConnection);
    } else {
        qCritical() << "TCPサーバーのリッスンに失敗しました:" << server.errorString();
    }

    return a.exec();
}

QTcpSocket::connectToHost() を使用する（TCPクライアントの場合）

TCPクライアント（QTcpSocket）がリモートホストに接続する場合、通常は connectToHost() 関数を使用します。この関数は、ソケットを ローカルの利用可能な任意のアドレスとポートに自動的にバインド してから、リモートホストへの接続を試みます。ほとんどのクライアントアプリケーションでは、どのローカルポートやIPアドレスを使うかに関心がないため、この自動的なバインドが非常に便利です。

利点

ほとんどのクライアントのユースケースに適合します。
開発者が明示的にローカルアドレスやポートを指定する必要がなく、OSが最適な設定を選んでくれるため、コードがシンプルになります。

使用例

#include <QTcpSocket>
#include <QHostAddress>
#include <QDebug>

// MyTcpClientクラス（詳細な実装は省略。前回の説明の例2を参照）
// class MyTcpClient : public QObject { ... };

int main(int argc, char *argv[]) {
    QCoreApplication a(argc, argv);

    QTcpSocket clientSocket;

    // シグナルとスロットを接続
    // QObject::connect(&clientSocket, &QTcpSocket::connected, &myClientObject, &MyClientObject::handleConnected);
    // QObject::connect(&clientSocket, QOverload<QAbstractSocket::SocketError>::of(&QTcpSocket::error), &myClientObject, &MyClientObject::handleError);

    // リモートホストに接続。ローカルバインドはOSに任せる
    clientSocket.connectToHost("example.com", 80); // 例: ウェブサーバーに接続

    if (clientSocket.waitForConnected(3000)) { // 3秒待機（ブロッキング呼び出し、GUIスレッドでは非推奨）
        qDebug() << "リモートホストに接続しました！";
        qDebug() << "ローカルアドレス:" << clientSocket.localAddress().toString()
                 << ", ローカルポート:" << clientSocket.localPort();
    } else {
        qCritical() << "接続に失敗しました:" << clientSocket.errorString();
    }

    return a.exec();
}

ソケットデスクリプタをラップする (setSocketDescriptor())

これはあまり一般的ではありませんが、既存のネイティブソケットデスクリプタ（例: C言語の socket() 関数で作成されたソケット）を Qt の QAbstractSocket オブジェクトにラップしたい場合に使える方法です。ネイティブソケットは、Qt の外で bind() などの操作を含めてすでに設定されている可能性があります。

利点

非常に低レベルなソケットオプションの制御が必要な場合に、ネイティブAPIで設定した後、Qtに引き継ぐことができる。
既存のC/C++ベースのソケットコードをQtのイベントループやシグナル・スロットシステムに統合できる。

使用例

#include <QAbstractSocket>
#include <QDebug>

#ifdef Q_OS_UNIX
#include <sys/socket.h>
#include <arpa/inet.h>
#include <unistd.h>
#endif

// QAbstractSocketを継承したカスタムソケットクラスなど
class MyWrappedSocket : public QAbstractSocket
{
    Q_OBJECT
public:
    explicit MyWrappedSocket(QObject *parent = nullptr) : QAbstractSocket(QAbstractSocket::UnknownSocketType, parent) {}

    // 既存のソケットデスクリプタを設定するメソッド
    bool wrapNativeSocket(qintptr socketDescriptor, QAbstractSocket::SocketState initialState) {
        return setSocketDescriptor(socketDescriptor, initialState);
    }
};

int main(int argc, char *argv[]) {
    QCoreApplication a(argc, argv);

#ifdef Q_OS_UNIX
    // 1. ネイティブのソケットを作成し、バインドする（例としてUDPソケット）
    int nativeSocketFd = socket(AF_INET, SOCK_DGRAM, 0);
    if (nativeSocketFd == -1) {
        qCritical() << "ネイティブソケットの作成に失敗しました。";
        return -1;
    }

    sockaddr_in addr;
    memset(&addr, 0, sizeof(addr));
    addr.sin_family = AF_INET;
    addr.sin_addr.s_addr = htonl(INADDR_ANY); // 0.0.0.0
    addr.sin_port = htons(12346); // 例: ポート12346

    if (::bind(nativeSocketFd, (sockaddr*)&addr, sizeof(addr)) == -1) {
        qCritical() << "ネイティブソケットのバインドに失敗しました。";
        ::close(nativeSocketFd);
        return -1;
    }

    qDebug() << "ネイティブソケットがポート12346にバインドされました。";

    // 2. MyWrappedSocket（またはQUdpSocket）でネイティブソケットをラップ
    QUdpSocket qtSocket; // QAbstractSocketの派生クラス
    // QAbstractSocket* qtSocket = new MyWrappedSocket(); // カスタムクラスの場合

    // setSocketDescriptorで既存のネイティブソケットをQtオブジェクトに引き渡す
    // QAbstractSocket::BoundState は、既にバインド済みであることを示す
    if (qtSocket.setSocketDescriptor(nativeSocketFd, QAbstractSocket::BoundState)) {
        qDebug() << "Qtソケットがネイティブソケットをラップしました。";
        qDebug() << "ローカルポート (Qt):" << qtSocket.localPort();
        // 以降はQtのシグナル・スロットでデータを扱う
        // QObject::connect(&qtSocket, &QUdpSocket::readyRead, ...);
    } else {
        qCritical() << "Qtソケットによるネイティブソケットのラップに失敗しました:" << qtSocket.errorString();
        ::close(nativeSocketFd); // ラップ失敗時は手動で閉じる
    }

    // Qtアプリケーションのイベントループ
    return a.exec();

#else
    qDebug() << "この例はUnix系OS (Linux/macOS) でのみ動作します。";
    return 0;
#endif
}

Windowsではソケットデスクリプタが SOCKET 型であり、Unix系の int とは異なります。プラットフォーム依存のコードが必要です。
ネイティブソケットデスクリプタのライフサイクル管理が複雑になる可能性があります。

高度なユースケース: ネイティブソケットの統合が必要な場合は setSocketDescriptor() が検討されます。
UDPソケット（サーバー/ピア）: QUdpSocket::bind() を明示的に呼び出すのが一般的です。これは、特定のポートでデータグラムをリッスンする必要があるためです。
TCPクライアント: QTcpSocket::connectToHost() が推奨されます。
TCPサーバー: QTcpServer::listen() が推奨されます。

【Qt入門】QAbstractSocket::bind()を使ったUDP/TCPソケットプログラミング例

主な目的

関数のシグネチャ

具体的な使用例

注意点

QAbstractSocket::AddressInUseError (アドレスが既に使用中)

QAbstractSocket::SocketAccessError (ソケットアクセス権限のエラー)

QAbstractSocket::SocketAddressNotAvailableError (指定されたアドレスが利用不可)

QAbstractSocket::NetworkError (一般的なネットワークエラー)

QAbstractSocket::UnsupportedSocketOperationError (サポートされていないソケット操作)

例1: UDPサーバー（データグラム受信）

例2: TCPクライアントで特定のローカルIPアドレスから接続を開始する

例3: QTcpServerによるサーバー構築（bind()の暗黙的呼び出し）

QTcpServer::listen() を使用する（TCPサーバーの場合）

QTcpSocket::connectToHost() を使用する（TCPクライアントの場合）

ソケットデスクリプタをラップする (setSocketDescriptor())

例3: `QTcpServer`によるサーバー構築（`bind()`の暗黙的呼び出し）