QtのwaitForBytesWritten()とは？ソケットデータ送信の完全ガイド

2025-05-26

QAbstractSocket::waitForBytesWritten() は、Qtのネットワークプログラミングで使用される関数で、ソケットに書き込まれたデータが実際にデバイス（ネットワーク）に送信されるまで、または指定された時間が経過するまで、現在のスレッドの実行を**ブロック（同期的に待機）**させるためのものです。

bytesWritten() シグナルとの関連
内部的には、この関数はデータが書き込まれたときに発生する bytesWritten() シグナルが発せられるまで待機します。
引数
- msecs (ミリ秒): 待機する最大時間。デフォルトは30000ミリ秒（30秒）です。-1 を指定すると、タイムアウトせずにデータが書き込まれるまで無限に待機します。
返り値
- true: 指定された時間内にデータがデバイスに書き込まれた場合。
- false: タイムアウトした場合、またはエラーが発生した場合。
同期的な待機
この関数は、データがソケットの内部バッファから実際に送信されるのを待機します。通常、Qtのネットワーク操作は非同期的に行われます（つまり、データを書き込むwrite()関数を呼び出してもすぐにデータが送信されるとは限りません）。waitForBytesWritten() を使うことで、この非同期的な動作を同期的な動作に一時的に変更できます。

使用目的・メリット

シーケンシャルなデータ送信の保証
特定のデータを送信し終えてから次の処理に進みたい場合など、データの送信完了を確実に待ちたい場合に役立ちます。
イベントループがない環境での使用
GUIアプリケーションのようにイベントループが常に動作している環境では、通常、非同期のシグナル/スロット機構（bytesWritten() シグナルを接続して処理するなど）を使用することが推奨されます。しかし、イベントループが存在しない（例：非GUIアプリケーションや別のスレッドでI/O操作を行う場合）環境では、waitForBytesWritten() のようなブロッキング関数が便利です。

注意点・デメリット

書き込みバッファの監視
Qtは書き込みバッファのサイズを制限しません。waitForBytesWritten() はバッファが書き込まれるのを待つだけで、バッファのオーバーフローを防ぐわけではありません。バッファのサイズを監視したい場合は、bytesWritten() シグナルを利用するのが適切です。
「UnconnectedState」での使用不可
ソケットが接続されていない UnconnectedState のときにこの関数を呼び出すとエラーになります。ソケットが ConnectedState にあることを確認してから使用する必要があります。
非効率性
ブロッキング操作は、システムの他のタスクの実行を妨げる可能性があるため、一般的には非同期的なアプローチよりも効率が悪いとされています。
GUIのフリーズ
GUIアプリケーションのメインスレッドで waitForBytesWritten() を呼び出すと、データの送信が完了するまでGUIが応答しなくなり、アプリケーションがフリーズしたように見えます。これはQtのイベントループがブロックされるためです。GUIアプリケーションでは、この関数をメインスレッドで使用することは強く推奨されません。

代替手段（GUIアプリケーションの場合）

GUIアプリケーションでブロッキングを避けたい場合は、以下の方法を検討してください。

別スレッドでのI/O操作
ネットワーク通信を別のQThreadで実行し、メインスレッドのGUIをブロックしないようにする方法です。QObject::moveToThread() を使用してソケットオブジェクトを別のスレッドに移動させることができます。
bytesWritten() シグナルの利用
QAbstractSocket::write() でデータを書き込んだ後、bytesWritten() シグナルにスロットを接続し、データが実際に送信されたことを検知して次の処理を行うのが、Qtらしい非同期的なアプローチです。

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

int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv); // 非GUIアプリケーション向け

    QTcpSocket socket;
    socket.connectToHost("example.com", 80);

    if (socket.waitForConnected(3000)) { // 接続を待機
        qDebug() << "Connected!";
        QByteArray data = "GET / HTTP/1.1\r\nHost: example.com\r\nConnection: close\r\n\r\n";
        socket.write(data);

        // データが送信されるまで待機（最大5秒）
        if (socket.waitForBytesWritten(5000)) {
            qDebug() << "Bytes written successfully!";
            // 次の処理へ...
        } else {
            qDebug() << "Failed to write bytes or timed out:" << socket.errorString();
        }

        socket.close();
    } else {
        qDebug() << "Failed to connect:" << socket.errorString();
    }

    return a.exec(); // イベントループを開始（必要に応じて）
}

QAbstractSocket::waitForBytesWritten() はブロッキング関数であるため、その特性を理解せずに使用すると、様々な問題を引き起こす可能性があります。

GUIのフリーズ (最も一般的で深刻な問題)

エラー/症状

アプリケーション全体が一時的に固まる。
アプリケーションのGUIが応答しなくなる（ウィンドウが灰色になる、ボタンがクリックできないなど）。

原因

waitForBytesWritten() がGUIスレッド（メインスレッド）で呼び出され、ソケットがデータの送信を完了するまでイベントループがブロックされてしまうため。

トラブルシューティング

別のスレッドでI/O操作を行う
ネットワーク通信を専用の QThread で実行し、結果をメインスレッドにシグナルで通知します。これにより、UIの応答性を保ちながらブロッキングI/Oも可能になります。

非同期的なアプローチに切り替える

データを書き込んだ後、QAbstractSocket::bytesWritten() シグナルにスロットを接続し、このシグナルが発行されたときに次の処理を実行するようにします。これがQtのイベント駆動型プログラミングの基本です。

例:

// .h
class MyClient : public QObject
{
    Q_OBJECT
public:
    MyClient(QObject *parent = nullptr);
    void sendData(const QByteArray &data);
private slots:
    void onBytesWritten(qint64 bytes);
    void onError(QAbstractSocket::SocketError error);
private:
    QTcpSocket *socket;
    QByteArray dataToSend;
};

// .cpp
MyClient::MyClient(QObject *parent) : QObject(parent)
{
    socket = new QTcpSocket(this);
    connect(socket, &QTcpSocket::bytesWritten, this, &MyClient::onBytesWritten);
    connect(socket, &QTcpSocket::errorOccurred, this, &MyClient::onError);
    // ... 接続処理など ...
}

void MyClient::sendData(const QByteArray &data)
{
    dataToSend = data; // 送信するデータを保存しておく
    socket->write(dataToSend);
}

void MyClient::onBytesWritten(qint64 bytes)
{
    qDebug() << bytes << "bytes written.";
    // 必要に応じて、残りのデータを送信したり、次の処理に進む
    if (socket->bytesToWrite() == 0) {
        qDebug() << "All data sent.";
        // データ送信完了後の処理
    }
}

void MyClient::onError(QAbstractSocket::SocketError error)
{
    qDebug() << "Socket error:" << socket->errorString();
}

waitForBytesWritten() をメインスレッドで使用しない
これが最も重要な解決策です。

QAbstractSocket::waitForBytesWritten() is not allowed in UnconnectedState

エラー/症状

waitForBytesWritten() が false を返す。
アプリケーション実行中にコンソールに上記のエラーメッセージが出力される。

原因

ソケットが UnconnectedState (未接続状態) のときに waitForBytesWritten() を呼び出している。waitForBytesWritten() はソケットが ConnectedState にあることを前提としています。

トラブルシューティング

接続処理を待つ

connectToHost() を呼び出した後、waitForConnected() を使用して接続が確立されるのを待つか、connected() シグナルを待ちます。

例:

// Blocking approach (avoid in GUI main thread)
socket->connectToHost("server.com", 12345);
if (socket->waitForConnected(5000)) { // 接続が確立されるまで待機
    socket->write("Hello");
    if (socket->waitForBytesWritten(3000)) { // データの書き込みを待機
        qDebug() << "Data sent successfully.";
    } else {
        qDebug() << "waitForBytesWritten timed out or error:" << socket->errorString();
    }
} else {
    qDebug() << "Connection failed or timed out:" << socket->errorString();
}

ソケットの状態を確認する
socket->state() を使用して、waitForBytesWritten() を呼び出す前にソケットが QAbstractSocket::ConnectedState であることを確認します。

waitForBytesWritten() が false を返し、データが送信されない

エラー/症状

期待したデータが受信側で確認できない。
socket->error() または socket->errorString() を確認すると、何らかのエラーメッセージが表示される。
waitForBytesWritten() が false を返す。

原因

データの書き込み忘れ
write() を呼び出していないか、データが空である。
書き込みバッファの不足
（可能性は低いが）内部バッファが一時的に詰まっている。
ソケットエラー
ネットワークの問題、接続の切断、権限の問題など、ソケット自体にエラーが発生している。
タイムアウト
指定した msecs 時間内にデータが送信されなかった。これは、ネットワークが遅い、またはリモートエンドがデータを処理していない場合に発生します。

トラブルシューティング

デバッグ出力の活用
qDebug() を使って、接続状態、書き込みバイト数、エラーなどを詳細に出力し、処理の流れを追跡します。
bytesToWrite() の値を確認する
socket->bytesToWrite() がゼロになっているか確認し、まだ書き込むべきデータが残っているかを確認します。
リモートサーバーの状況を確認する
サーバーが稼働しているか、期待されるポートでリッスンしているか、データを受信して処理する準備ができているかを確認します。
ネットワーク接続を確認する
物理的なネットワークケーブル、Wi-Fi接続、ファイアウォールの設定などを確認します。
タイムアウト時間を長くする
ネットワークの状況に応じて、msecs の値を増やしてみる。
socket->error() と socket->errorString() を確認する
これらはエラーの具体的な原因を特定する上で最も重要です。例えば RemoteHostClosedError であれば、相手側が接続を切断したことを意味します。

想定外の動作 (特にUDPの場合)

エラー/症状

UDPソケットで waitForBytesWritten() を使用しても期待通りの動作にならない。

原因

QAbstractSocket::waitForBytesWritten() は、TCPソケットのように接続指向のプロトコルで内部バッファの送信完了を待つことを意図しています。UDPはコネクションレスなプロトコルであり、データグラムの送信完了は保証されません。writeDatagram() を呼び出した時点で、システムがデータグラムを送信キューに入れたと見なされ、それ以上の「書き込み完了」の概念は薄いです。

トラブルシューティング

UDPの場合は、waitForBytesWritten() の代わりに writeDatagram() の成功（戻り値が書き込んだバイト数と一致するか）を確認し、それ以上は待機しないのが一般的です。UDPは信頼性の保証がないため、アプリケーションレベルで再送処理などを実装する必要があります。

プロジェクト設定の不足

エラー/症状

ビルドエラーが発生し、ネットワーク関連のクラスが見つからないと表示される。

原因

.pro ファイルに network モジュールが追加されていない。

Qtプロジェクトの .pro ファイルに以下の行を追加します。
```
QT += network
```
変更後、qmakeを再実行し、プロジェクトをリビルドしてください。

Qt の bool QAbstractSocket::waitForBytesWritten() は、データをソケットに書き込んだ後、そのデータが実際にネットワークに送信されるまで（または指定した時間まで）プログラムの実行をブロックする関数です。この関数は、主に以下のような状況で役立ちます。

特定のデータの送信完了を待機したい場合
シーケンシャルな通信プロトコルで、前のデータの送信が完了してから次のデータを送信したい場合など。
イベントループがない環境
GUIを持たないコンソールアプリケーションや、独自のイベントループを持たないスレッドでネットワーク通信を行う場合。

ただし、GUIアプリケーションのメインスレッドでこれを使用すると、GUIがフリーズする原因となるため、強く推奨されません。GUIアプリケーションでは、通常は非同期的なシグナルとスロットのメカニズムを使用すべきです。

以下に、waitForBytesWritten() を使用する際のコード例をいくつか示します。それぞれの例の目的と注意点を明確にします。

例1: コンソールアプリケーションでの基本的な使用 (TCPクライアント)

この例は、GUIを持たないシンプルなTCPクライアントがサーバーにメッセージを送信し、その送信が完了するまで待機するシナリオです。

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

int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv); // GUIを持たないアプリケーション用

    QTcpSocket socket;
    QString hostName = "localhost"; // サーバーのホスト名またはIPアドレス
    quint16 port = 12345;          // サーバーのポート番号

    qDebug() << "Connecting to" << hostName << ":" << port << "...";

    // サーバーへの接続を試みる
    socket.connectToHost(hostName, port);

    // 接続が確立されるまで最大5秒待機する
    if (!socket.waitForConnected(5000)) {
        qDebug() << "Connection failed:" << socket.errorString();
        return 1; // エラー終了
    }

    qDebug() << "Connected!";

    // 送信するデータ
    QByteArray data = "Hello from Qt client!\r\n";
    qDebug() << "Writing data:" << data;

    // データをソケットに書き込む
    qint64 bytesWritten = socket.write(data);
    if (bytesWritten == -1) {
        qDebug() << "Error writing data:" << socket.errorString();
        socket.close();
        return 1;
    }

    qDebug() << "Wrote" << bytesWritten << "bytes to socket buffer. Waiting for transmission...";

    // データを実際にネットワークに送信するまで最大10秒待機する
    if (socket.waitForBytesWritten(10000)) {
        qDebug() << "Data successfully transmitted!";
    } else {
        qDebug() << "Failed to transmit data or timed out:" << socket.errorString();
    }

    // サーバーからの応答を待機する（オプション）
    qDebug() << "Waiting for response...";
    if (socket.waitForReadyRead(5000)) {
        QByteArray response = socket.readAll();
        qDebug() << "Received response:" << response;
    } else {
        qDebug() << "No response received or timed out:" << socket.errorString();
    }

    // ソケットを閉じる
    socket.disconnectFromHost();
    if (!socket.waitForDisconnected(3000)) {
        qDebug() << "Failed to disconnect cleanly:" << socket.errorString();
    }
    qDebug() << "Disconnected.";

    return 0; // 正常終了
}

解説

QCoreApplication を使用しているため、GUIはブロックされません（そもそもGUIがありません）。
waitForConnected() で接続が確立されるのを待機します。
write() でデータを内部バッファに書き込みます。この時点ではまだネットワークに送信されているとは限りません。
waitForBytesWritten() で、内部バッファのデータが実際にネットワーク層に書き込まれるのを待ちます。成功すれば true を返し、失敗またはタイムアウトすれば false を返します。
エラーが発生した場合 (false を返した場合) には、socket.errorString() で詳細なエラーメッセージを取得します。

GUIアプリケーションであっても、ネットワーク通信を別のスレッドに分離することで、メインスレッドのGUIをフリーズさせずにブロッキング操作を行うことができます。

MyWorker.h

#ifndef MYWORKER_H
#define MYWORKER_H

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

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

public slots:
    void doWork(const QString &host, quint16 port, const QByteArray &message);

signals:
    void workFinished(bool success, const QString &result);
    void error(const QString &errorMessage);

private:
    QTcpSocket *socket;
};

#endif // MYWORKER_H

MyWorker.cpp

#include "MyWorker.h"

MyWorker::MyWorker(QObject *parent) : QObject(parent)
{
    socket = new QTcpSocket(this); // QObjectの親子関係でソケットの寿命を管理
}

MyWorker::~MyWorker()
{
    if (socket->state() != QAbstractSocket::UnconnectedState) {
        socket->abort(); // 確実に接続を閉じる
    }
    qDebug() << "MyWorker destroyed.";
}

void MyWorker::doWork(const QString &host, quint16 port, const QByteArray &message)
{
    qDebug() << "Worker: Connecting to" << host << ":" << port << "...";

    socket->connectToHost(host, port);
    if (!socket->waitForConnected(5000)) {
        emit error(QString("Worker: Connection failed: %1").arg(socket->errorString()));
        emit workFinished(false, "");
        return;
    }

    qDebug() << "Worker: Connected! Writing data:" << message;
    qint64 bytes = socket->write(message);

    if (bytes == -1) {
        emit error(QString("Worker: Error writing data: %1").arg(socket->errorString()));
        socket->close();
        emit workFinished(false, "");
        return;
    }

    qDebug() << "Worker: Wrote" << bytes << "bytes. Waiting for transmission...";
    if (socket->waitForBytesWritten(10000)) {
        qDebug() << "Worker: Data transmitted successfully!";
        // 応答を待機する（オプション）
        if (socket->waitForReadyRead(5000)) {
            QByteArray response = socket->readAll();
            qDebug() << "Worker: Received response:" << response;
            emit workFinished(true, QString(response));
        } else {
            emit error(QString("Worker: No response or read timeout: %1").arg(socket->errorString()));
            emit workFinished(false, "");
        }
    } else {
        emit error(QString("Worker: Failed to transmit data or timed out: %1").arg(socket->errorString()));
        emit workFinished(false, "");
    }

    socket->disconnectFromHost();
    if (!socket->waitForDisconnected(3000)) {
        qDebug() << "Worker: Failed to disconnect cleanly:" << socket->errorString();
    }
}

main.cpp (GUIアプリケーションの例)

#include <QApplication>
#include <QPushButton>
#include <QThread>
#include <QLabel>
#include <QVBoxLayout>
#include "MyWorker.h" // MyWorkerをインクルード

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

    QWidget window;
    QVBoxLayout *layout = new QVBoxLayout(&window);
    QLabel *statusLabel = new QLabel("Ready to send message.");
    QPushButton *sendButton = new QPushButton("Send Message (Blocking in Thread)");

    layout->addWidget(statusLabel);
    layout->addWidget(sendButton);
    window.setWindowTitle("Threaded Blocking Socket Example");
    window.show();

    // ワーカーオブジェクトとスレッドを作成
    QThread *workerThread = new QThread();
    MyWorker *worker = new MyWorker();

    // ワーカーオブジェクトをスレッドに移動
    worker->moveToThread(workerThread);

    // シグナルとスロットの接続 (スレッドセーフな接続)
    QObject::connect(sendButton, &QPushButton::clicked, worker, [worker, statusLabel]() {
        // メインスレッドからワーカーのスロットを呼び出す
        // これはQThread::start()後に接続する必要がある
        statusLabel->setText("Sending message... (GUI remains responsive)");
        worker->doWork("localhost", 12345, "Message from threaded client!");
    });

    QObject::connect(worker, &MyWorker::workFinished, statusLabel, [statusLabel](bool success, const QString &result) {
        if (success) {
            statusLabel->setText(QString("Message sent! Response: %1").arg(result));
        } else {
            statusLabel->setText("Message sending failed.");
        }
    });

    QObject::connect(worker, &MyWorker::error, statusLabel, [statusLabel](const QString &errorMessage) {
        statusLabel->setText(QString("Error: %1").arg(errorMessage));
    });

    // スレッド終了時のクリーンアップ
    QObject::connect(workerThread, &QThread::finished, worker, &QObject::deleteLater);
    QObject::connect(workerThread, &QThread::finished, workerThread, &QObject::deleteLater);

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

    int ret = a.exec();

    // アプリケーション終了時にスレッドを終了させる
    workerThread->quit();
    workerThread->wait(); // スレッドが終了するまで待機

    return ret;
}

MyWorker クラス内で QTcpSocket をインスタンス化し、ネットワーク通信のロジック (doWork スロット) を記述します。このスロット内で waitForConnected(), waitForBytesWritten(), waitForReadyRead() といったブロッキング関数を使用します。
main.cpp では、MyWorker インスタンスを QThread インスタンスに moveToThread() で移動させます。これにより、doWork スロットが呼び出されると、その処理は新しく作成されたスレッドで実行され、メインスレッドのGUIはブロックされません。
QPushButton のクリックシグナルを MyWorker::doWork スロットに接続します。
MyWorker からの workFinished や error シグナルを QLabel に接続し、通信結果をGUIに表示します。
アプリケーション終了時に workerThread->quit() と workerThread->wait() を呼び出して、スレッドが安全に終了するのを待ちます。

bytesWritten() シグナルとスロットの利用 (推奨される非同期アプローチ)

これがQtのネットワークプログラミングにおける最も標準的で推奨される方法です。QAbstractSocket は非同期で動作し、特定のイベントが発生したときにシグナルを発行します。データがソケットに書き込まれた（内部バッファから実際に送信された）ときに bytesWritten() シグナルが発行されます。

メリット

効率的
イベント駆動型であるため、リソースを効率的に利用できます。
GUIの応答性維持
メインスレッドがブロックされないため、GUIアプリケーションは常に応答性を保ちます。

デメリット

コードのフローが waitForBytesWritten() のような同期的なコードよりも複雑に感じられる場合があります（状態管理や複数のシグナル/スロット接続が必要になるため）。

実装例

// MyTcpClient.h
#ifndef MYTCPCLIENT_H
#define MYTCPCLIENT_H

#include <QObject>
#include <QTcpSocket>
#include <QByteArray>
#include <QDebug>

class MyTcpClient : public QObject
{
    Q_OBJECT
public:
    explicit MyTcpClient(QObject *parent = nullptr);
    void connectAndSendData(const QString &host, quint16 port, const QByteArray &data);

private slots:
    void onConnected();
    void onDisconnected();
    void onBytesWritten(qint64 bytes);
    void onReadyRead();
    void onErrorOccurred(QAbstractSocket::SocketError socketError);

private:
    QTcpSocket *socket;
    QByteArray currentDataToSend;
    qint64 totalBytesToWrite;
    qint64 bytesWrittenSoFar;
};

#endif // MYTCPCLIENT_H

// MyTcpClient.cpp
#include "MyTcpClient.h"

MyTcpClient::MyTcpClient(QObject *parent) : QObject(parent)
{
    socket = new QTcpSocket(this);

    // シグナルとスロットの接続
    connect(socket, &QTcpSocket::connected, this, &MyTcpClient::onConnected);
    connect(socket, &QTcpSocket::disconnected, this, &MyTcpClient::onDisconnected);
    connect(socket, &QTcpSocket::bytesWritten, this, &MyTcpClient::onBytesWritten);
    connect(socket, &QTcpSocket::readyRead, this, &MyTcpClient::onReadyRead);
    connect(socket, QOverload<QAbstractSocket::SocketError>::of(&QAbstractSocket::errorOccurred),
            this, &MyTcpClient::onErrorOccurred);

    totalBytesToWrite = 0;
    bytesWrittenSoFar = 0;
}

void MyTcpClient::connectAndSendData(const QString &host, quint16 port, const QByteArray &data)
{
    currentDataToSend = data;
    totalBytesToWrite = data.size();
    bytesWrittenSoFar = 0;

    qDebug() << "Attempting to connect to" << host << ":" << port;
    socket->connectToHost(host, port);
}

void MyTcpClient::onConnected()
{
    qDebug() << "Connected to host!";
    // 接続確立後、データの書き込みを開始
    if (!currentDataToSend.isEmpty()) {
        qint64 bytes = socket->write(currentDataToSend);
        if (bytes == -1) {
            qDebug() << "Error writing initial data:" << socket->errorString();
            socket->close();
        } else if (bytes < totalBytesToWrite) {
            // データの一部が書き込まれた場合（大きなデータを送る場合）
            bytesWrittenSoFar += bytes;
            qDebug() << bytes << "bytes written to buffer. Total so far:" << bytesWrittenSoFar;
        } else {
            // データ全体が一度に書き込まれた場合
            bytesWrittenSoFar = totalBytesToWrite;
            qDebug() << "All" << bytesWrittenSoFar << "bytes written to buffer.";
        }
    }
}

void MyTcpClient::onDisconnected()
{
    qDebug() << "Disconnected from host.";
}

void MyTcpClient::onBytesWritten(qint64 bytes)
{
    // このスロットは、ソケットの内部書き込みバッファのデータが実際に送信されたときに呼び出される
    bytesWrittenSoFar += bytes;
    qDebug() << bytes << "bytes transmitted. Total transmitted:" << bytesWrittenSoFar << "of" << totalBytesToWrite;

    if (bytesWrittenSoFar >= totalBytesToWrite) {
        qDebug() << "All data transmitted successfully!";
        // 全てのデータが送信された後の処理
        // 例: サーバーからの応答を待つ、接続を閉じるなど
        // socket->disconnectFromHost();
    } else {
        // まだ送信すべきデータが残っている場合 (大きなデータを分割して送る場合)
        // 例えば、次のチャンクを書き込む
        // qint64 remaining = totalBytesToWrite - bytesWrittenSoFar;
        // socket->write(currentDataToSend.mid(bytesWrittenSoFar, qMin(remaining, (qint64)someChunkSize)));
    }
}

void MyTcpClient::onReadyRead()
{
    // サーバーからデータが受信された場合の処理
    QByteArray data = socket->readAll();
    qDebug() << "Received data:" << data;
}

void MyTcpClient::onErrorOccurred(QAbstractSocket::SocketError socketError)
{
    Q_UNUSED(socketError); // 使わない引数であることを明示
    qDebug() << "Socket error:" << socket->errorString();
}

// main.cpp (GUIアプリケーションまたはQCoreApplication)
#include <QCoreApplication> // GUIがない場合
// #include <QApplication> // GUIがある場合
#include "MyTcpClient.h"

int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv); // または QApplication a(argc, argv);

    MyTcpClient client;
    client.connectAndSendData("localhost", 12345, "Hello, non-blocking world!");

    // イベントループを開始
    return a.exec();
}

解説

大きなデータを送信する場合、write() が一度にすべてのデータを書き込めないことがあります。その場合、bytesWritten() シグナルが複数回発生し、残りのデータも送信されたことを通知します。
onBytesWritten() スロットでは、実際に送信されたバイト数 (bytes) を受け取り、送信完了の進捗を管理できます。
socket->write() はデータをソケットの内部バッファに書き込むだけです。実際にネットワークにデータが送られたことを知るには、bytesWritten() シグナルを監視します。

QEventLoop を使用した擬似的なブロッキング (慎重な使用が必要)

QEventLoop を使用すると、特定のシグナルが発行されるまで、現在のスレッドのイベントループを一時的に実行させることができます。これは waitForBytesWritten() の内部的な動作に似ていますが、より柔軟な制御が可能です。ただし、これもGUIの応答性を損なう可能性があるため、メインスレッドでの使用は避けるべきです。

メリット

タイムアウトや特定のシグナルなど、より複雑な待機条件を設定できます。
waitForBytesWritten() のように、コードを同期的に書くことができます。

デメリット

デッドロックのリスクがあるため、慎重な設計が必要です。
メインスレッドで使用するとGUIがフリーズします。

実装例

#include <QCoreApplication>
#include <QTcpSocket>
#include <QDebug>
#include <QEventLoop> // QEventLoop を使用

void sendDataBlockingPseudo(QTcpSocket *socket, const QByteArray &data, int timeoutMsecs)
{
    if (socket->state() != QAbstractSocket::ConnectedState) {
        qDebug() << "Socket not connected. Cannot send data.";
        return;
    }

    qDebug() << "Writing data:" << data;
    qint64 bytesWritten = socket->write(data);

    if (bytesWritten == -1) {
        qDebug() << "Error writing data to buffer:" << socket->errorString();
        return;
    }

    if (bytesWritten == data.size()) {
        qDebug() << "All data written to buffer. Waiting for transmission...";
    } else {
        qDebug() << "Part of data written to buffer. Waiting for transmission...";
        // ここで残りのデータを管理する必要があるが、簡略化のため省略
    }

    QEventLoop loop;
    // bytesWritten シグナルが発生したらループを終了
    QObject::connect(socket, &QTcpSocket::bytesWritten, &loop, &QEventLoop::quit);
    // エラーが発生した場合もループを終了
    QObject::connect(socket, QOverload<QAbstractSocket::SocketError>::of(&QAbstractSocket::errorOccurred), &loop, &QEventLoop::quit);

    // タイムアウトを設定
    QTimer timer;
    timer.setSingleShot(true);
    QObject::connect(&timer, &QTimer::timeout, &loop, &QEventLoop::quit);
    timer.start(timeoutMsecs);

    loop.exec(); // イベントループをブロックして待機

    if (timer.isActive()) { // タイムアウトせずにループが終了した場合
        timer.stop();
        if (socket->error() == QAbstractSocket::SocketError::UnknownSocketError) {
             // bytesWritten シグナルで終了した可能性が高い
             qDebug() << "Data transmission seems complete (or socket error occurred).";
             // 実際の送信完了は bytesToWrite() で確認すべきだが、ここでは簡略化
             if (socket->bytesToWrite() == 0) {
                 qDebug() << "All bytes cleared from write buffer.";
             } else {
                 qDebug() << "Still bytes in write buffer:" << socket->bytesToWrite();
             }
        } else {
            qDebug() << "Socket error during transmission:" << socket->errorString();
        }
    } else {
        qDebug() << "Data transmission timed out.";
    }
}

// main関数 (例1と同じ構造)
// この sendDataBlockingPseudo 関数をメインスレッドで呼び出す場合は、
// GUIがフリーズすることに注意してください。
// 例1のMyWorkerクラス内のような別スレッドでの使用が適切です。

解説

タイマーを使用してタイムアウトを実装しています。
loop.exec() を呼び出すと、イベントループが一時的にブロックされ、接続されたシグナルが発行されるか、タイムアウトするまでイベントを処理し続けます。
QEventLoop をインスタンス化し、socket->bytesWritten() や socket->errorOccurred() シグナルに loop.quit() スロットを接続します。

マルチスレッド (上記「例2: スレッド内での waitForBytesWritten() の使用」を参照)

これは、waitForBytesWritten() を使用する最も安全な方法です。ネットワークI/Oを専用のワーカー（作業者）スレッドにオフロードし、そのスレッド内でブロッキング操作を実行します。メインスレッドはGUIの更新やユーザーインタラクションに専念できます。

メリット

ブロッキングAPIを安全に使用できます。
ネットワーク通信のロジックをメインスレッドから分離できるため、コードの可読性と保守性が向上します。
GUIの応答性を完全に維持できます。

デメリット

スレッド間のデータ受け渡しには、シグナル/スロットやミューテックスなどの同期メカニズムを適切に使用する必要があります。
スレッドの管理（作成、開始、終了、オブジェクトの移動）に関するオーバーヘッドがあります。

Qt Concurrent / C++11 std::async (高度な選択肢)

Qt Concurrent や C++11 の std::async を使用して、ネットワーク操作をバックグラウンドで実行することも可能です。これらはスレッド管理を抽象化してくれるため、より簡潔にマルチスレッド処理を記述できます。

メリット

並列処理を容易に記述できます。
明示的な QThread 管理よりもコードが簡潔になる場合があります。

デメリット

Qtのシグナル/スロットと組み合わせるには、結果をメインスレッドに渡すための工夫が必要です。
ソケットオブジェクトのライフサイクル管理が複雑になることがあります。特に、ソケットが QObject の親子関係にあり、メインスレッドのイベントループに属している場合、別のスレッドで直接操作することはスレッドアフィニティのルールに違反する可能性があります。

簡単な概念例 (非推奨な直接利用の可能性も含むため注意)

// これは概念的なコードであり、QTcpSocket のスレッドアフィニティの問題を解決していません
// 実際のプロダクションコードでは、QTcpSocket オブジェクトを QThread::moveToThread() で
// バックグラウンドスレッドに移動させるか、MyWorkerのような専用のクラスを使用すべきです。

#include <QCoreApplication>
#include <QTcpSocket>
#include <QDebug>
#include <QtConcurrent/QtConcurrent> // Qt Concurrent を使用
#include <QFuture>

// ネットワーク操作をバックグラウンドで実行する関数
// この関数は、QTcpSocket のスレッドアフィニティを考慮していません
// 実際には、MyWorker のようにソケットオブジェクトをスレッドに移動させるべきです。
bool performNetworkOperation(const QString &host, quint16 port, const QByteArray &data)
{
    QTcpSocket socket; // このソケットは、この関数が実行されるスレッドに属します
    socket.connectToHost(host, port);
    if (!socket.waitForConnected(5000)) {
        qDebug() << "Error connecting:" << socket.errorString();
        return false;
    }

    socket.write(data);
    if (!socket.waitForBytesWritten(10000)) {
        qDebug() << "Error writing bytes:" << socket.errorString();
        socket.close();
        return false;
    }

    socket.close();
    return true;
}

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

    // QtConcurrent を使用してバックグラウンドで実行
    QFuture<bool> future = QtConcurrent::run(performNetworkOperation, "localhost", 12345, "Hello from concurrent!");

    // 結果が準備できるまで待機（この行はメインスレッドをブロックするが、
    // 実際のアプリケーションではQtConcurrent::map/filter/reduceやQFutureWatcherを使うことが多い）
    future.waitForFinished();

    if (future.result()) {
        qDebug() << "Concurrent operation successful!";
    } else {
        qDebug() << "Concurrent operation failed!";
    }

    return a.exec();
}

重要な注意点
QTcpSocket のような QObject ベースのオブジェクトは、作成されたスレッドにアフィニティを持ちます。つまり、そのオブジェクトのメソッドやスロットは、そのオブジェクトが属するスレッドからのみ呼び出すべきです。QtConcurrent::run や std::async で新しいスレッドで関数を実行する場合、その関数内で直接 QTcpSocket をインスタンス化して使用すれば問題ありません（ソケットはその新しいスレッドのアフィニティを持つため）。しかし、メインスレッドで作成した QTcpSocket オブジェクトを別のスレッドに渡して操作しようとすると、スレッドアフィニティの問題でクラッシュや未定義動作の原因となります。このため、スレッド間で QObject を安全に操作するには、QObject::moveToThread() を使うのが最も一般的で安全な方法です。

Qt のネットワークプログラミングでは、ほとんどの場合、bytesWritten() や readyRead() といった非同期シグナルを利用したイベント駆動型プログラミングが最も推奨されます。これにより、GUIの応答性を維持し、アプリケーション全体のパフォーマンスを向上させることができます。