QAbstractSocket::setSocketDescriptor()を使わないQtソケット通信のベストプラクティス

2025-05-27

この関数は、既存のネイティブソケットディスクリプタ（OSが提供するソケットの識別子）をQAbstractSocketオブジェクトに関連付けるために使用されます。つまり、Qtのソケット抽象化レイヤーを、すでに作成・設定されている低レベルのソケットの上に構築することができます。

主な用途と機能

既存のネイティブソケットをラップする:
- 通常、Qtでソケットを使用する場合、QTcpSocketやQUdpSocketのインスタンスを直接作成し、connectToHost()やbind()といったQtのAPIを使って接続やバインドを行います。
- しかし、何らかの理由でQtの外部（例えば、C++標準ライブラリやOSのAPI）でソケットを作成・設定し、そのソケットをQtのイベントループやシグナル/スロット機構と連携させたい場合に、setSocketDescriptor()が役立ちます。
- この関数を呼び出すことで、QAbstractSocketのインスタンスが、引数として渡されたsocketDescriptor（ソケットのファイルディスクリプタやハンドル）を内部的に利用するようになります。
戻り値:
- ソケットディスクリプタのセットアップが成功した場合にtrueを返します。
- 失敗した場合（例：無効なディスクリプタが渡された場合など）はfalseを返します。
引数:
- int socketDescriptor: 関連付けたいネイティブソケットのディスクリプタ（Unix系OSではファイルディスクリプタ、Windowsではソケットハンドル）。
- SocketState state = ConnectedState: ソケットの初期状態を指定します。デフォルトはConnectedStateで、ソケットがすでに接続済みであることを想定しています。必要に応じて、UnconnectedStateやBoundStateなどを指定することも可能です。
- OpenMode openMode = ReadWrite: ソケットの開モードを指定します。デフォルトはReadWriteで、読み書き両方が可能であることを意味します。

使用例（概念）

#include <QtNetwork/QAbstractSocket>
#include <iostream>

// 仮のネイティブソケット作成関数 (実際にはOSのAPIを使用)
int createNativeSocket() {
    // ここでOS固有のソケット作成API (例: socket(), bind(), listen(), accept()) を呼び出す
    // 成功したらソケットディスクリプタを返す
    // 例: return socket(AF_INET, SOCK_STREAM, 0);
    std::cout << "ネイティブソケットを作成しました (仮)" << std::endl;
    return 123; // 仮の値
}

int main() {
    // QCoreApplicationなどのイベントループが必要な場合があります
    // QCoreApplication app(argc, argv);

    int nativeSock = createNativeSocket(); // ネイティブソケットを作成

    if (nativeSock != -1) { // ソケット作成が成功した場合
        QAbstractSocket *socket = new QTcpSocket(); // または QAbstractSocketを直接インスタンス化

        // ネイティブソケットディスクリプタをQtソケットに関連付ける
        if (socket->setSocketDescriptor(nativeSock)) {
            std::cout << "ソケットディスクリプタのセットアップに成功しました。" << std::endl;
            // これで、QtのQAbstractSocket API（read(), write(), readyRead()シグナルなど）
            // をこのネイティブソケットに対して使用できます。
            // 例: socket->write("Hello from Qt!");
        } else {
            std::cerr << "ソケットディスクリプタのセットアップに失敗しました。" << std::endl;
            // エラー処理
        }
    } else {
        std::cerr << "ネイティブソケットの作成に失敗しました。" << std::endl;
    }

    // Qtアプリケーションのイベントループを開始する場合
    // return app.exec();
    return 0;
}

注意点

QTcpSocketやQUdpSocketは、内部で自動的にソケットディスクリプタを管理します。
この関数は、主に特殊なケースや、Qtと低レベルなソケットAPIを混在させる必要がある場合に使用されます。通常は、直接QTcpSocketやQUdpSocketをインスタンス化して使用する方が簡単で、Qtの利点を最大限に活かせます。
setSocketDescriptor()を使用する場合、ネイティブソケットのライフサイクル管理（作成、クローズなど）は開発者の責任になります。Qtのソケットオブジェクトが破棄されても、ネイティブソケット自体は自動的にクローズされない場合があります。

`bool QAbstractSocket::setSocketDescriptor()`に関する一般的なエラーとトラブルシューティング

- エラーの状況
  setSocketDescriptor()がfalseを返す、またはQtのソケットが期待通りに動作しない（データの送受信ができない、接続状態にならないなど）。
- 原因
  - 渡されたsocketDescriptorが、有効なネイティブソケットディスクリプタ（ファイルディスクリプタ、ソケットハンドル）ではない。
  - ネイティブソケットがすでに閉じられている、または無効な状態になっている。
  - ネイティブソケットが、QAbstractSocketが期待するソケットタイプ（TCPの場合はストリームソケット、UDPの場合はデータグラムソケットなど）ではない。
- トラブルシューティング
  - socketDescriptorの検証
    setSocketDescriptor()を呼び出す前に、ネイティブソケットディスクリプタがOSレベルで有効であり、適切に初期化されていることを確認します。例えば、socket()やaccept()などのOS APIの戻り値をチェックし、エラーがないことを確認します。
  - ソケットの型
    ネイティブソケットが、QTcpSocketであればTCPストリームソケット、QUdpSocketであればUDPデータグラムソケットであることを確認します。異なるソケットタイプをsetSocketDescriptor()で設定しようとすると、予測不能な動作を引き起こす可能性があります。
  - エラーコードの確認
    OSのソケットAPI（GetLastError() on Windows, errno on Unix/Linux）を使用して、ネイティブソケット作成時のエラーを確認します。
ソケットの状態の不一致 (state引数の誤り)
- エラーの状況
  setSocketDescriptor()は成功するものの、Qtのソケットオブジェクトの状態が期待と異なる、またはreadyRead()やconnected()などのシグナルが正しく発行されない。
- 原因
  setSocketDescriptor()に渡すstate引数が、実際のネイティブソケットの状態と一致していない。例えば、ネイティブソケットがまだ接続されていないのにConnectedStateを渡したり、バインドされていないのにBoundStateを渡したりする。
- トラブルシューティング
  - 実際のソケット状態の確認
    setSocketDescriptor()を呼び出す前に、ネイティブソケットが実際にどの状態にあるのか（connect()されているか、bind()されているかなど）を把握し、それに合わせてstate引数を設定します。通常、QTcpServer::incomingConnection()から受け取ったソケットディスクリプタをsetSocketDescriptor()に渡す場合は、ConnectedStateが適切です。
ライフサイクル管理の問題（最も一般的）
- エラーの状況
  - Qtのソケットオブジェクトが破棄された後、ネイティブソケットがリークする（閉じられない）。
  - ネイティブソケットが外部で閉じられた後、Qtのソケットオブジェクトがクラッシュしたり、無効な操作を行おうとしたりする。
  - 複数のQtソケットオブジェクトが同じネイティブソケットディスクリプタを使用しようとする（これはQt 5.10以降でsetSocketDescriptorがqintptrを受け取るようになったことで、より厳密に管理されるべき）。
- 原因
  - setSocketDescriptor()はQtソケットにネイティブソケットの所有権を移譲するわけではないため、ネイティブソケットのクローズは開発者の責任で行う必要があります。
  - ネイティブソケットが外部でクローズされたにもかかわらず、Qtのソケットオブジェクトがそれを使おうとしている。
  - スレッド間でソケットディスクリプタを共有しようとしているが、Qtのソケットは通常、それを作成したスレッドのイベントループで動作することを期待している。
- トラブルシューティング
  - 所有権の明確化
    どちらがネイティブソケットのライフサイクル（オープン、クローズ）を管理するのかを明確に定義します。通常は、setSocketDescriptor()を呼び出した後、Qtのソケットオブジェクトにネイティブソケットの管理を任せるべきですが、Qtのソケットオブジェクトが破棄されたときにネイティブソケットが自動的にクローズされるかどうかはQtのバージョンや実装に依存する可能性があります。明示的にネイティブソケットをクローズするタイミングを考慮します。
  - クローズの連携
    ネイティブソケットを外部でクローズする場合、Qtのソケットオブジェクトのclose()またはabort()を呼び出すか、Qtソケットオブジェクトを削除することで、Qt側のリソースも適切に解放されるようにします。
  - 二重管理の回避
    同じネイティブソケットディスクリプタを複数のQAbstractSocketオブジェクトにセットしないようにします。これにより、「Invalid Socket Descriptor」エラーやクラッシュが発生する可能性があります。
  - スレッドの考慮
    Qtのソケットは通常、それらが作成されたスレッドのイベントループ内で動作することを期待します。異なるスレッドでネイティブソケットを作成し、それを別のスレッドのQAbstractSocketオブジェクトに渡す場合は、moveToThread()を使用してソケットオブジェクトを適切なスレッドに移動させるか、スレッドセーフな設計を慎重に行う必要があります。
イベントループとの連携不足
- エラーの状況
  setSocketDescriptor()は成功するが、readyRead()などのシグナルが発行されない、またはデータの送受信がトリガーされない。
- 原因
  QAbstractSocketはQtのイベントループに依存して動作します。setSocketDescriptor()で既存のソケットを関連付けた後も、Qtのイベントループが実行されていないと、ソケットイベント（データ受信、接続状態の変化など）を処理できません。
- トラブルシューティング
  - QCoreApplicationの実行
    GUIアプリケーションであればQApplication、非GUIアプリケーションであればQCoreApplicationのインスタンスが存在し、exec()が呼び出されてイベントループが開始されていることを確認します。
  - シグナル/スロットの接続
    readyRead()、connected()、disconnected()、error()などの関連するシグナルを、適切なスロットに接続していることを確認します。
SSL/TLS関連のエラー (QSslSocketの場合)
- エラーの状況
  QSslSocketでsetSocketDescriptor()を使用した後、SSLハンドシェイクが失敗する、またはsslErrors()シグナルが発行される。
- 原因
  QSslSocketは、ネイティブソケットが確立された後にSSLハンドシェイクを実行する必要があります。このハンドシェイクが失敗する原因は多岐にわたります（証明書の問題、プロトコルバージョンの不一致、設定ミスなど）。
- トラブルシューティング
  - startClientEncryption() / startServerEncryption()の呼び出し
    setSocketDescriptor()の後、明示的にQSslSocket::startClientEncryption()またはQSslSocket::startServerEncryption()を呼び出してSSLハンドシェイクを開始する必要があります。
  - SSL証明書とキー
    サーバー側であれば適切なサーバー証明書と秘密鍵が設定されているか、クライアント側であれば信頼できるCA証明書が設定されているかを確認します。
  - sslErrors()シグナルの処理
    sslErrors()シグナルを接続し、エラーの詳細を確認します。必要に応じてignoreSslErrors()を呼び出してエラーを無視することも可能ですが、セキュリティリスクを伴うため注意が必要です。

ネイティブソケットのデバッグ
必要であれば、OSレベルのツール（例: netstat, lsof）を使用して、ネイティブソケットの実際の状態を確認します。
QAbstractSocket::state()とstateChanged()シグナル
ソケットの状態の変化を追跡するために、state()メソッドやstateChanged()シグナルを活用します。setSocketDescriptor()を呼び出した後のソケットの状態が期待通りになっているかを確認します。
QAbstractSocket::error()とQAbstractSocket::errorString()
エラーが発生した場合、error()メソッドでエラータイプを取得し、errorString()で詳細なエラーメッセージを取得してログに出力します。これにより、問題の特定に役立ちます。
setSocketDescriptor()の戻り値のチェック
常にsetSocketDescriptor()の戻り値を確認し、falseが返された場合はエラー処理を行います。

ここでは、setSocketDescriptor() を使用する具体的なプログラミング例をいくつか紹介します。

QTcpServerとスレッドで利用する一般的なケース

QTcpServerが新しい接続を受け入れた際に、その接続を別のスレッドで処理する場合にsetSocketDescriptor()がよく利用されます。QTcpServer::incomingConnection()は、接続されたソケットのディスクリプタ（qintptr型）を引数として提供します。このディスクリプタを新しいスレッドに渡すことで、そのスレッド内でQTcpSocketオブジェクトを作成し、ネイティブソケットをQtソケットに関連付けることができます。

サーバー側のコード (メインスレッド)

// main.cpp または QTcpServer を継承したクラスのファイル
#include <QCoreApplication>
#include <QTcpServer>
#include <QTcpSocket>
#include <QThread>
#include <QDebug>

// 新しいクライアント接続を処理するスレッド
class ClientHandlerThread : public QThread
{
    Q_OBJECT
public:
    explicit ClientHandlerThread(qintptr socketDescriptor, QObject *parent = nullptr)
        : QThread(parent), m_socketDescriptor(socketDescriptor)
    {}

    void run() override {
        QTcpSocket socket; // QTcpSocketはスタックでもヒープでもOKですが、親オブジェクトをnullptrに設定します
                          // このソケットオブジェクトはスレッドが終了すると自動的に破棄されます。

        // ネイティブソケットディスクリプタをQtソケットに関連付け
        if (!socket.setSocketDescriptor(m_socketDescriptor)) {
            qWarning() << "Error setting socket descriptor:" << socket.errorString();
            return;
        }

        // ここでシグナル/スロットを接続し、ソケットからのデータ読み込みや書き込みを行う
        // 注意: Qt::DirectConnection を使用するか、ソケットのイベントループをスレッド内で開始する必要があります
        // 今回はスレッドのイベントループを利用するため、通常通り接続します
        connect(&socket, &QTcpSocket::readyRead, this, [&]() {
            QByteArray data = socket.readAll();
            qDebug() << "Thread" << QThread::currentThreadId() << ": Received:" << data;
            socket.write("Echo: " + data);
        });
        connect(&socket, &QTcpSocket::disconnected, this, [&]() {
            qDebug() << "Thread" << QThread::currentThreadId() << ": Client disconnected.";
            quit(); // スレッドのイベントループを終了
        });
        connect(&socket, &QTcpSocket::errorOccurred, this, [&](QAbstractSocket::SocketError socketError) {
            qWarning() << "Thread" << QThread::currentThreadId() << ": Socket error:" << socket.errorString();
            quit(); // エラー発生時もスレッドのイベントループを終了
        });

        qDebug() << "Thread" << QThread::currentThreadId() << ": Client connected.";

        // スレッドのイベントループを開始し、ソケットからのイベントを処理
        exec(); // QThread::run() の中で exec() を呼び出すことで、このスレッド専用のイベントループが開始される
    }

private:
    qintptr m_socketDescriptor;
};

// サーバークラス
class MyTcpServer : public QTcpServer
{
    Q_OBJECT
public:
    explicit MyTcpServer(QObject *parent = nullptr) : QTcpServer(parent) {}

protected:
    void incomingConnection(qintptr socketDescriptor) override {
        qDebug() << "New incoming connection. Socket Descriptor:" << socketDescriptor;

        // 新しいスレッドを作成し、ソケットディスクリプタを渡す
        ClientHandlerThread *thread = new ClientHandlerThread(socketDescriptor, this); // 親をMyTcpServerに設定
        connect(thread, &QThread::finished, thread, &QObject::deleteLater); // スレッド終了時にオブジェクトを削除

        thread->start(); // スレッドを開始
    }
};

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

    MyTcpServer server;
    quint16 port = 12345;
    if (!server.listen(QHostAddress::Any, port)) {
        qCritical() << "Could not start server:" << server.errorString();
        return 1;
    }
    qDebug() << "Server listening on port" << port;

    return a.exec();
}

#include "main.moc" // Qtのmocツールによって生成されるファイル

クライアント側のコード (テスト用)

#include <QCoreApplication>
#include <QTcpSocket>
#include <QDebug>
#include <QTimer>

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

    QTcpSocket clientSocket;
    clientSocket.connectToHost("localhost", 12345);

    QObject::connect(&clientSocket, &QTcpSocket::connected, [&]() {
        qDebug() << "Client connected!";
        clientSocket.write("Hello, server!");
    });

    QObject::connect(&clientSocket, &QTcpSocket::readyRead, [&]() {
        QByteArray data = clientSocket.readAll();
        qDebug() << "Client received:" << data;
        clientSocket.disconnectFromHost(); // 接続を終了
    });

    QObject::connect(&clientSocket, &QTcpSocket::disconnected, [&]() {
        qDebug() << "Client disconnected.";
        a.quit(); // アプリケーションを終了
    });

    QObject::connect(&clientSocket, &QTcpSocket::errorOccurred, [&](QAbstractSocket::SocketError socketError) {
        qWarning() << "Client error:" << clientSocket.errorString();
        a.quit();
    });

    return a.exec();
}

説明

スレッド側 (ClientHandlerThread)
- run()メソッド内で、QTcpSocketオブジェクト（socket）を作成します。
- socket.setSocketDescriptor(m_socketDescriptor)を呼び出し、渡されたネイティブソケットディスクリプタをこのQTcpSocketに関連付けます。これにより、Qtのソケット機能（シグナル/スロット、read()、write()など）を既存のネイティブソケットに対して使用できるようになります。
- readyRead()、disconnected()、errorOccurred()などのシグナルを接続し、ソケットイベントを処理します。
- exec()を呼び出すことで、このスレッド独自のイベントループが開始され、ソケットイベントが処理されるようになります。
サーバー側
- MyTcpServerクラスはQTcpServerを継承しています。
- incomingConnection(qintptr socketDescriptor)メソッドがオーバーライドされています。このメソッドは、新しいクライアントが接続されたときにQTcpServerによって呼び出され、接続されたネイティブソケットのディスクリプタをsocketDescriptorとして渡します。
- このsocketDescriptorをClientHandlerThreadのコンストラクタに渡し、新しいスレッドを作成して開始します。

Qtの外部で（例えば、OSのソケットAPIを使って）ソケットを作成・設定し、それをQtのソケットオブジェクトで管理したい場合にsetSocketDescriptor()を使用できます。

#include <QCoreApplication>
#include <QTcpSocket>
#include <QDebug>

#ifdef Q_OS_WIN
#include <winsock2.h> // Windows ソケットAPI
#pragma comment(lib, "ws2_32.lib")
#else
#include <sys/socket.h> // Unix/Linux ソケットAPI
#include <arpa/inet.h>
#include <unistd.h>     // close()
#endif

// ネイティブソケットを作成し、接続する関数 (例として)
qintptr createAndConnectNativeSocket() {
#ifdef Q_OS_WIN
    WSADATA wsaData;
    if (WSAStartup(MAKEWORD(2, 2), &wsaData) != 0) {
        qWarning() << "WSAStartup failed.";
        return -1;
    }
    SOCKET sock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
    if (sock == INVALID_SOCKET) {
        qWarning() << "Native socket creation failed:" << WSAGetLastError();
        WSACleanup();
        return -1;
    }

    sockaddr_in serverAddr;
    serverAddr.sin_family = AF_INET;
    serverAddr.sin_port = htons(12345); // サーバーのポート
    serverAddr.sin_addr.s_addr = inet_addr("127.0.0.1"); // サーバーのIP

    if (::connect(sock, (SOCKADDR*)&serverAddr, sizeof(serverAddr)) == SOCKET_ERROR) {
        qWarning() << "Native socket connect failed:" << WSAGetLastError();
        closesocket(sock);
        WSACleanup();
        return -1;
    }
    return (qintptr)sock;
#else
    int sock = socket(AF_INET, SOCK_STREAM, 0);
    if (sock < 0) {
        qWarning() << "Native socket creation failed:" << strerror(errno);
        return -1;
    }

    struct sockaddr_in serverAddr;
    serverAddr.sin_family = AF_INET;
    serverAddr.sin_port = htons(12345); // サーバーのポート
    inet_pton(AF_INET, "127.0.0.1", &serverAddr.sin_addr); // サーバーのIP

    if (::connect(sock, (struct sockaddr*)&serverAddr, sizeof(serverAddr)) < 0) {
        qWarning() << "Native socket connect failed:" << strerror(errno);
        ::close(sock);
        return -1;
    }
    return (qintptr)sock;
#endif
}

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

    qintptr nativeSocketDescriptor = createAndConnectNativeSocket();

    if (nativeSocketDescriptor == -1) {
        qWarning() << "Failed to create and connect native socket.";
        return 1;
    }

    QTcpSocket *qtSocket = new QTcpSocket(&a); // 親オブジェクトを設定

    // ネイティブソケットディスクリプタをQtソケットに関連付け
    // ここで ConnectedState を渡すのは、すでに接続済みと想定しているため
    if (qtSocket->setSocketDescriptor(nativeSocketDescriptor, QAbstractSocket::ConnectedState)) {
        qDebug() << "Successfully set socket descriptor for QtSocket.";

        // これで、QtのソケットAPIを使用できる
        QObject::connect(qtSocket, &QTcpSocket::readyRead, [&]() {
            QByteArray data = qtSocket->readAll();
            qDebug() << "QtSocket received:" << data;
        });

        QObject::connect(qtSocket, &QTcpSocket::disconnected, [&]() {
            qDebug() << "QtSocket disconnected.";
            a.quit();
        });

        QObject::connect(qtSocket, &QTcpSocket::errorOccurred, [&](QAbstractSocket::SocketError socketError) {
            qWarning() << "QtSocket error:" << qtSocket->errorString();
            a.quit();
        });

        // データの送信
        qtSocket->write("Hello from Qt using wrapped native socket!");
        qDebug() << "Sent data from QtSocket.";

    } else {
        qWarning() << "Failed to set socket descriptor for QtSocket:" << qtSocket->errorString();
        // ネイティブソケットを明示的にクローズする必要がある
#ifdef Q_OS_WIN
        closesocket((SOCKET)nativeSocketDescriptor);
        WSACleanup();
#else
        ::close((int)nativeSocketDescriptor);
#endif
        return 1;
    }

    return a.exec();
}

重要な注意点
setSocketDescriptor()を使用した場合、Qtのソケットオブジェクトが破棄されても、ネイティブソケットディスクリプタが自動的にクローズされないことがあります。例では、setSocketDescriptor()が失敗した場合に明示的にネイティブソケットをクローズしています。成功した場合は、Qtソケットがそのソケットを管理すると期待されますが、ライフサイクル管理には常に注意が必要です。
これにより、qtSocketに対してreadyRead()シグナルやwrite()メソッドなどのQtのソケットAPIを使用できるようになります。
qtSocket->setSocketDescriptor(nativeSocketDescriptor, QAbstractSocket::ConnectedState)を呼び出すことで、Qtのソケットオブジェクトが既存のネイティブソケットディスクリプタを「採用」します。
main関数内で、このネイティブソケットディスクリプタを取得し、QTcpSocketオブジェクトを作成します。
この例では、createAndConnectNativeSocket()というヘルパー関数が、OS固有のAPI（WindowsのWinsockまたはUnix/LinuxのPOSIXソケットAPI）を使用してネイティブTCPソケットを作成し、特定のサーバー（例: 127.0.0.1:12345）に接続します。

Qt の提供する高レベルソケットクラスを直接使用する

これが Qt でソケットプログラミングを行う際の最も推奨される方法です。Qt は、TCP や UDP のソケット通信を簡単に扱えるように、専用のクラスを提供しています。

QUdpSocket (UDP ソケット)

UDP プロトコルを使用したデータグラムベースの通信を扱います。
接続指向ではないため、TCP のような connectToHost() や listen() はありません。代わりに bind() して特定のポートからのデータグラムを待ち受けます。

例 (UDP 送受信)

#include <QUdpSocket>
#include <QCoreApplication>
#include <QDebug>

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

    QUdpSocket socket;
    // ポートにバインドしてデータを受信する
    if (!socket.bind(QHostAddress::Any, 12346)) {
        qCritical() << "UDP bind failed:" << socket.errorString();
        return 1;
    }
    qDebug() << "UDP socket bound to port 12346.";

    QObject::connect(&socket, &QUdpSocket::readyRead, [&]() {
        while (socket.hasPendingDatagrams()) {
            QNetworkDatagram datagram = socket.receiveDatagram();
            qDebug() << "Received UDP from" << datagram.senderAddress().toString()
                     << ":" << datagram.senderPort() << " -> " << datagram.data();

            // 受信したアドレスに返信
            socket.writeDatagram("Echo: " + datagram.data(), datagram.senderAddress(), datagram.senderPort());
        }
    });

    // 別のソケットでデータを送信してみる（同じプロセス内）
    QUdpSocket senderSocket;
    senderSocket.writeDatagram("Hello UDP world!", QHostAddress::LocalHost, 12346);
    qDebug() << "Sent UDP datagram.";

    QTimer::singleShot(2000, &a, [&a](){ a.quit(); }); // 2秒後に終了

    return a.exec();
}

QTcpServer (TCP サーバー)

着信接続をリッスンし、受け入れるためのサーバーソケットを扱います。
listen() を呼び出すだけで、指定されたアドレスとポートで接続を待ち受けます。
新しい接続があるたびに newConnection() シグナルを発行し、nextPendingConnection() で接続された QTcpSocket オブジェクトを取得できます。このソケットは Qt によって完全に管理されます。

例 (TCP サーバー)

#include <QTcpServer>
#include <QTcpSocket>
#include <QCoreApplication>
#include <QDebug>

class MyServer : public QTcpServer {
    Q_OBJECT
public:
    explicit MyServer(QObject *parent = nullptr) : QTcpServer(parent) {}

protected:
    void incomingConnection(qintptr socketDescriptor) override {
        qDebug() << "New connection coming! Socket Descriptor (handled by Qt):" << socketDescriptor;
        QTcpSocket *socket = new QTcpSocket(this); // QTcpServerを親にする
        if (!socket->setSocketDescriptor(socketDescriptor)) {
            // このケースでは、QTcpServer::incomingConnectionがすでにソケットディスクリプタを
            // QTcpSocketに割り当てようとしているため、通常は必要ありません。
            // QTcpServer::incomingConnectionのデフォルト実装は、
            // 受け入れたソケットディスクリプタからQTcpSocketを作成し、
            // nextPendingConnection()で提供します。
            // したがって、このオーバーライドでsetSocketDescriptor()を呼ぶのは、
            // 特殊なカスタマイズが必要な場合を除き、通常は不要です。
            // デフォルトの実装では、受け入れたソケットディスクリプタから
            // QTcpSocketオブジェクトを自動的に作成し、
            // nextPendingConnection()から返せるようにします。
            // ここでは説明のため、あえてsetSocketDescriptor()を記述しますが、
            // 実際には以下のように newConnection() シグナルを使うのが一般的です。
        }

        // 通常は nextPendingConnection() を使う
        // QTcpSocket *clientSocket = nextPendingConnection(); // incomingConnection内で呼ぶべきではない
                                                              // NewConnectionシグナルで呼び出す
        // QTcpServer::incomingConnectionのデフォルト実装により、
        // 新しい接続がnewConnection()シグナルで報告され、
        // nextPendingConnection()で取得できるようになります。
        // したがって、このメソッドをオーバーライドして手動でソケットを扱う必要は通常ありません。
        // 以下のコメントアウトされたコードは、デフォルトの動作を示唆しています。
        // nextPendingConnection()は、newConnection()シグナルから呼び出すのが適切です。

        // 例として、手動でソケットを管理する場合（このケースでは setSocketDescriptor が使われている）
        // この MyServer クラスは、QTcpServer のデフォルトの newConnection() シグナル/nextPendingConnection() の
        // 動作を置き換えるのではなく、IncomingConnection をオーバーライドする特殊な例としてのみ提示します。
        // 実際のサーバーでは、MyServer のコンストラクタで connect(this, &QTcpServer::newConnection, this, &MyServer::handleNewConnection);
        // のようにシグナル/スロットを接続するのが普通です。
        qDebug() << "Handling connection via setSocketDescriptor (example only, usually rely on newConnection)";
        // 通常のincomingConnectionの実装は、以下の1行で十分です:
        // emit newConnection();
        // その後、newConnection()シグナルに接続されたスロットで nextPendingConnection() を呼び出します。

        // ここではあくまでsetSocketDescriptor()の例として、強制的にソケットを作成します。
        // これにより、Qt のイベントループにソケットが登録されます。
        // デフォルトの incomingConnection() は内部でこれを処理します。
        // QTcpSocket *clientSocket = new QTcpSocket(this);
        // clientSocket->setSocketDescriptor(socketDescriptor); // 通常は不要
        // connect(clientSocket, &QTcpSocket::readyRead, this, [&]() {
        //    qDebug() << "Server received:" << clientSocket->readAll();
        //    clientSocket->write("Echo from server!");
        // });
        // connect(clientSocket, &QTcpSocket::disconnected, clientSocket, &QTcpSocket::deleteLater);
    }
};

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

    MyServer server;
    quint16 port = 12345;
    if (!server.listen(QHostAddress::Any, port)) {
        qCritical() << "Could not start server:" << server.errorString();
        return 1;
    }
    qDebug() << "Server listening on port" << port;

    // サーバーが新しい接続を受け入れたときに呼び出される
    QObject::connect(&server, &QTcpServer::newConnection, [&]() {
        // nextPendingConnection()で接続されたソケットを取得する
        QTcpSocket *clientSocket = server.nextPendingConnection();
        qDebug() << "New client connected from" << clientSocket->peerAddress().toString();

        QObject::connect(clientSocket, &QTcpSocket::readyRead, [&]() {
            QByteArray data = clientSocket->readAll();
            qDebug() << "Server received:" << data;
            clientSocket->write("Echo: " + data);
        });

        QObject::connect(clientSocket, &QTcpSocket::disconnected, clientSocket, &QTcpSocket::deleteLater);
        QObject::connect(clientSocket, QOverload<QAbstractSocket::SocketError>::of(&QTcpSocket::errorOccurred),
                         [&](QAbstractSocket::SocketError socketError) {
            Q_UNUSED(socketError);
            qWarning() << "Client socket error:" << clientSocket->errorString();
            clientSocket->deleteLater();
        });
    });

    return a.exec();
}
#include "main.moc" // mocファイルが必要

注意
QTcpServer::incomingConnection() をオーバーライドしてsetSocketDescriptor() を手動で呼び出す例は、特殊なカスタマイズが必要な場合にのみ使用されます。Qt の通常のサーバープログラミングでは、QTcpServer::newConnection() シグナルに接続し、そのスロット内で server.nextPendingConnection() を呼び出して QTcpSocket オブジェクトを取得するのが一般的です。この方法は、ソケットのライフサイクル管理を Qt に任せるため、より安全で簡単です。

QTcpSocket (TCP クライアント/サーバーの接続ソケット)

TCP プロトコルを使用したストリームベースの通信を扱います。
クライアントとしてサーバーに接続したり、サーバーが受け入れた個々の接続（ピアソケット）を表したりします。
setSocketDescriptor() を使わずに、connectToHost() で接続を開始したり、QTcpServer::nextPendingConnection() で取得したソケットを使ったりします。

#include <QTcpSocket>
#include <QCoreApplication>
#include <QDebug>

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

    QTcpSocket socket;
    // サーバーに接続する
    socket.connectToHost("localhost", 12345);

    QObject::connect(&socket, &QTcpSocket::connected, [&]() {
        qDebug() << "Connected to server!";
        socket.write("Hello from Qt client!"); // データ送信
    });

    QObject::connect(&socket, &QTcpSocket::readyRead, [&]() {
        QByteArray data = socket.readAll();
        qDebug() << "Received from server:" << data;
        socket.disconnectFromHost();
    });

    QObject::connect(&socket, &QTcpSocket::disconnected, [&]() {
        qDebug() << "Disconnected from server.";
        a.quit();
    });

    QObject::connect(&socket, QOverload<QAbstractSocket::SocketError>::of(&QTcpSocket::errorOccurred),
                     [&](QAbstractSocket::SocketError socketError) {
        Q_UNUSED(socketError); // エラーの種類が必要なければ無視
        qWarning() << "Socket error:" << socket.errorString();
        a.quit();
    });

    return a.exec();
}

スレッドでソケットを扱う際の推奨アプローチ

setSocketDescriptor() が使われる主要なシナリオの一つに、QTcpServer::incomingConnection() から取得したソケットディスクリプタを別のスレッドに渡して処理する、というものがあります。しかし、この場合でも setSocketDescriptor() を直接使うのは必ずしも最善ではありません。

ソケットオブジェクトをスレッドに移動する (moveToThread)

Qt のソケットオブジェクトは、それらが作成されたスレッドのイベントループ内で動作することを期待します。QTcpServer は通常、メインスレッドで動作するため、nextPendingConnection() で取得した QTcpSocket もメインスレッドに属します。
このソケットを別のスレッドで処理したい場合、QObject::moveToThread() を使用して、ソケットオブジェクトを新しいスレッドのイベントループに移動させることができます。これにより、Qt がソケットのイベントを自動的に処理してくれます。

例 (サーバー側で moveToThread を利用)

#include <QCoreApplication>
#include <QTcpServer>
#include <QTcpSocket>
#include <QThread>
#include <QDebug>

// クライアント接続を処理するワーカーオブジェクト
class SocketWorker : public QObject
{
    Q_OBJECT
public slots:
    void handleSocket(QTcpSocket *socket) {
        // このスロットは、ソケットが移動したスレッドで実行されます。
        qDebug() << "Worker thread:" << QThread::currentThreadId() << " - Handling new socket.";

        connect(socket, &QTcpSocket::readyRead, this, [&]() {
            QByteArray data = socket->readAll();
            qDebug() << "Worker thread:" << QThread::currentThreadId() << ": Received:" << data;
            socket->write("Echo from worker: " + data);
        });

        connect(socket, &QTcpSocket::disconnected, this, [&]() {
            qDebug() << "Worker thread:" << QThread::currentThreadId() << ": Client disconnected.";
            socket->deleteLater(); // ソケットを安全に削除
            thread()->quit(); // ワーカーを保持するスレッドのイベントループを終了
        });

        connect(socket, QOverload<QAbstractSocket::SocketError>::of(&QTcpSocket::errorOccurred),
                [&](QAbstractSocket::SocketError socketError) {
            Q_UNUSED(socketError);
            qWarning() << "Worker thread:" << QThread::currentThreadId() << ": Socket error:" << socket->errorString();
            socket->deleteLater();
            thread()->quit();
        });
    }
};

// サーバークラス
class MyThreadedServer : public QTcpServer
{
    Q_OBJECT
public:
    explicit MyThreadedServer(QObject *parent = nullptr) : QTcpServer(parent) {}

protected:
    void incomingConnection(qintptr socketDescriptor) override {
        qDebug() << "New incoming connection. Socket Descriptor:" << socketDescriptor;

        // 新しいスレッドを作成
        QThread *thread = new QThread(this);
        SocketWorker *worker = new SocketWorker();
        worker->moveToThread(thread); // ワーカーオブジェクトを新しいスレッドに移動

        // ソケットをメインスレッドで作成し、新しいスレッドのイベントループに移動させる
        QTcpSocket *socket = new QTcpSocket(nullptr); // 親をnullにすると、後でmoveToThreadで管理しやすくなる
        socket->setSocketDescriptor(socketDescriptor); // ここでsetSocketDescriptorを使用

        // スレッドが開始されたら、ソケットの処理を開始するスロットを呼び出す
        connect(thread, &QThread::started, worker, [worker, socket]() {
            // ソケットをワーカーのスレッドに移動
            socket->moveToThread(worker->thread());
            // シグナルをQt::QueuedConnectionで接続し、ソケットの準備ができたことをワーカーに通知
            QMetaObject::invokeMethod(worker, "handleSocket", Qt::QueuedConnection, Q_ARG(QTcpSocket*, socket));
        });

        // スレッド終了時にワーカーとスレッドオブジェクトを削除
        connect(thread, &QThread::finished, worker, &QObject::deleteLater);
        connect(thread, &QThread::finished, thread, &QObject::deleteLater);

        thread->start();
    }
};

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

    MyThreadedServer server;
    quint16 port = 12345;
    if (!server.listen(QHostAddress::Any, port)) {
        qCritical() << "Could not start server:" << server.errorString();
        return 1;
    }
    qDebug() << "Server listening on port" << port;

    return a.exec();
}
#include "main.moc"

注意
この moveToThread を使った例でも setSocketDescriptor を使用しています。これは、QTcpServer::incomingConnection() がネイティブのソケットディスクリプタを渡すため、そのディスクリプタから Qt ソケットオブジェクトを作成する必要があるためです。しかし、この場合の setSocketDescriptor の役割は、ネイティブソケットを Qt の抽象化に「変換」することであり、QTcpServer::newConnection() シグナルを利用する通常のパターンに比べて、複雑さが増す可能性があります。

最も一般的なベストプラクティス
QTcpServer からのスレッド処理では、QTcpServer::newConnection() シグナルに接続し、server.nextPendingConnection() で取得した QTcpSocket* を、そのまま moveToThread() で新しいスレッドに移動させるのが最もシンプルで推奨される方法です。この場合、setSocketDescriptor() を直接呼ぶ必要はありません。

推奨される QTcpServer のスレッド処理例

#include <QCoreApplication>
#include <QTcpServer>
#include <QTcpSocket>
#include <QThread>
#include <QDebug>

// クライアント接続を処理するワーカーオブジェクト（前の例と同じ）
class SocketWorker : public QObject {
    Q_OBJECT
public slots:
    void handleSocket(QTcpSocket *socket) {
        // ... (内容は前の例と同じ) ...
        qDebug() << "Worker thread:" << QThread::currentThreadId() << " - Handling new socket.";
        connect(socket, &QTcpSocket::readyRead, this, [&]() {
            QByteArray data = socket->readAll();
            qDebug() << "Worker thread:" << QThread::currentThreadId() << ": Received:" << data;
            socket->write("Echo from worker: " + data);
        });
        connect(socket, &QTcpSocket::disconnected, this, [&]() {
            qDebug() << "Worker thread:" << QThread::currentThreadId() << ": Client disconnected.";
            socket->deleteLater();
            thread()->quit();
        });
        connect(socket, QOverload<QAbstractSocket::SocketError>::of(&QTcpSocket::errorOccurred),
                [&](QAbstractSocket::SocketError socketError) {
            Q_UNUSED(socketError);
            qWarning() << "Worker thread:" << QThread::currentThreadId() << ": Socket error:" << socket->errorString();
            socket->deleteLater();
            thread()->quit();
        });
    }
};

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

    QTcpServer server;
    quint16 port = 12345;
    if (!server.listen(QHostAddress::Any, port)) {
        qCritical() << "Could not start server:" << server.errorString();
        return 1;
    }
    qDebug() << "Server listening on port" << port;

    // newConnectionシグナルに接続
    QObject::connect(&server, &QTcpServer::newConnection, [&]() {
        QTcpSocket *socket = server.nextPendingConnection(); // Qtが作成したソケットオブジェクトを取得
        qDebug() << "New connection from" << socket->peerAddress().toString();

        QThread *thread = new QThread(&server); // サーバーを親にする
        SocketWorker *worker = new SocketWorker();
        worker->moveToThread(thread); // ワーカーを新しいスレッドに移動

        // スレッドが開始されたら、ソケットをワーカーのスレッドに移動させ、処理を開始
        QObject::connect(thread, &QThread::started, worker, [worker, socket]() {
            socket->moveToThread(worker->thread()); // ソケットをワーカーと同じスレッドに移動
            QMetaObject::invokeMethod(worker, "handleSocket", Qt::QueuedConnection, Q_ARG(QTcpSocket*, socket));
        });

        // スレッド終了時にオブジェクトをクリーンアップ
        QObject::connect(thread, &QThread::finished, worker, &QObject::deleteLater);
        QObject::connect(thread, &QThread::finished, thread, &QObject::deleteLater);

        thread->start();
    });

    return a.exec();
}
#include "main.moc"

この推奨される方法では、QTcpServer::nextPendingConnection() が既に有効な QTcpSocket オブジェクトを提供するため、setSocketDescriptor() を手動で呼び出す必要はなくなります。Qt がソケットの作成と基本的な初期化を管理してくれるため、よりエラーが少なく、保守しやすいコードになります。

bool QAbstractSocket::setSocketDescriptor() は、非常に限定された状況（例: QTcpServer::incomingConnection() のオーバーライドでネイティブディスクリプタを受け取り、それを手動で Qt ソケットにマッピングする場合など）でのみ必要となる特殊な機能です。

ほとんどの Qt アプリケーションでは、以下の高レベルな代替方法を使用することが推奨されます。

QTcpSocket を直接使用して TCP クライアント/サーバーのピアソケットを実装する。
QTcpServer を使用して TCP サーバーを実装し、newConnection() シグナルと nextPendingConnection() メソッドを活用する。
QUdpSocket を使用して UDP 通信を実装する。
スレッドでソケットを処理する場合は、QObject::moveToThread() を利用して Qt ソケットオブジェクトをスレッド間で移動させる。

QAbstractSocket::setSocketDescriptor()を使わないQtソケット通信のベストプラクティス

bool QAbstractSocket::setSocketDescriptor()に関する一般的なエラーとトラブルシューティング

QTcpServerとスレッドで利用する一般的なケース

Qt の提供する高レベルソケットクラスを直接使用する

スレッドでソケットを扱う際の推奨アプローチ

`bool QAbstractSocket::setSocketDescriptor()`に関する一般的なエラーとトラブルシューティング