QAbstractSocket::bytesAvailable()だけじゃない！Qtソケット通信の賢いデータ受信方法

この関数は、QAbstractSocket クラス（QTcpSocket や QUdpSocket の基底クラス）が提供するもので、現在ソケットの読み込みバッファに読み込み可能なバイト数が何バイトあるかを返します。

各要素の意味

• bytesAvailable(): 関数の名前で、「利用可能なバイト数」を意味します。
• QAbstractSocket: この関数が属するクラスです。これは、Qt におけるすべてのソケット通信（TCP、UDPなど）の共通のインターフェースを提供する抽象基底クラスです。
• qint64: 戻り値の型です。これは 64 ビット符号付き整数を意味します。非常に大きなデータ量も表現できるため、大量のデータを受信するソケット通信に適しています。

どのような時に使うのか？

bytesAvailable() は、主にソケットからデータを受信する際に、どれくらいのデータを読み込むことができるかを事前に知るために使われます。特に、次のような場面で役立ちます。

1. データが到着したかどうかの確認: QAbstractSocket は readyRead() シグナルを発行します。このシグナルは、ソケットに新しいデータが到着したことを通知します。readyRead() シグナルを受け取ったら、まず bytesAvailable() を呼び出して、実際にどれくらいのデータが読み込み可能かを確認します。もし 0 を返せば、まだ読み込めるデータがないか、エラーが発生している可能性があります。

2. 適切なサイズのバッファの確保: データを読み込む際には、通常、read() や readAll() などの関数を使用します。これらの関数は、読み込むデータのサイズを指定する必要がある場合があります。bytesAvailable() の戻り値を利用することで、読み込み可能なバイト数に合わせたバッファを動的に確保し、効率的にデータを読み込むことができます。

3. 部分的なデータの処理: ネットワーク経由でデータを受信する場合、一度にすべてのデータが到着するとは限りません。大きなファイルを送受信する場合など、データが分割されて到着することがよくあります。bytesAvailable() を使うことで、現時点で到着しているデータだけを読み込み、処理することができます。そして、残りのデータが到着したら、再び readyRead() シグナルが発行され、bytesAvailable() で確認してから読み込む、というような非同期的な処理が可能です。

使用例 (概念)

// ソケットオブジェクト（例: QTcpSocket* socket;）
// socket->readyRead() シグナルが発せられたときの slot 関数
void MyClass::readSocketData()
{
    qint64 availableBytes = socket->bytesAvailable();

    if (availableBytes > 0) {
        QByteArray data = socket->readAll(); // すべての利用可能なデータを読み込む
        // または、特定のサイズだけ読み込む場合
        // QByteArray data = socket->read(availableBytes);

        // 読み込んだデータを処理する
        // ...
    }
}

---

bytesAvailable() が常に 0 を返す / データが読み込めない

一般的な原因

• setReadBufferSize() の問題
  setReadBufferSize() を使用している場合、バッファサイズが非常に小さいと、一度に大量のデータを受信できないことがあります。ただし、これは bytesAvailable() が 0 を返す直接的な原因ではなく、データが部分的にしか読み込めない原因となることが多いです。
• データが実際に送信されていない
  相手側からデータが送信されていない限り、bytesAvailable() は常に 0 を返します。相手のプログラムが正しくデータを送信しているか確認してください。
• イベントループが実行されていない
  Qt のソケット通信はイベントループ（QCoreApplication::exec() など）に依存しています。イベントループが実行されていないと、ソケットのシグナルが発せられず、データが受信されません。
• readyRead() シグナルを処理していない
  bytesAvailable() は、QAbstractSocket が readyRead() シグナルを発行したときに、初めて意味のある値を返します。readyRead() シグナルを適切なスロットに接続し、そのスロット内で bytesAvailable() を確認し、データを読み込む必要があります。
• 接続が確立されていない
  最も基本的な原因です。ソケットがまだ接続されていない、または接続が切断されている場合、データは受信できません。QAbstractSocket::state() を確認し、QAbstractSocket::ConnectedState であることを確認してください。

トラブルシューティング

• 相手側の送信を確認する
  別のツール（Wiresharkなど）を使ってネットワークトラフィックを監視し、データが実際にソケットに送信されているかを確認します。
• デバッグ出力で bytesAvailable() の値を確認する
  qDebug() << "Bytes available:" << socket->bytesAvailable(); のように、readyRead() スロット内で実際に返される値を確認します。
• readyRead() シグナルの接続を確認する
  connect(socket, &QAbstractSocket::readyRead, this, &MyClass::readSocketData); のような形で、readyRead() シグナルが正しくスロットに接続されているか確認します。
• ソケットの状態を確認する
  socket->state() の戻り値をデバッグ出力で確認し、QAbstractSocket::ConnectedState になっているか確認します。

bytesAvailable() が予期しない値を返す / データが欠損する

一般的な原因

• QDataStream 使用時の問題
  QDataStream を使用してデータを読み込む際、bytesAvailable() を適切にチェックせずに operator>>() を呼び出すと、必要なデータが揃っていないために読み込みが失敗したり、不完全なデータを読み込んでしまったりすることがあります。
• バッファオーバーフローの誤解
  Qt の内部バッファは通常は自動的に拡張されますが、非常に短時間で大量のデータが押し寄せると、処理が追いつかない可能性があります。ただし、これは稀なケースです。
• データのパース方法の誤り
  受信したデータが構造化されている場合（例: ヘッダーに続くペイロード）、bytesAvailable() を確認せずに read() や readAll() を呼び出すと、意図したデータの一部しか読み込めないことがあります。
• 部分的なデータ到着の考慮不足
  bytesAvailable() は「現時点で」読み込み可能なバイト数を返します。大きなデータブロックを送信する場合、ネットワークの特性上、データが一度にすべて到着するとは限りません。例えば、100バイト送っても、最初は50バイトしか到着せず、その後残りの50バイトが到着するといったことが起こり得ます。

トラブルシューティング

• QDataStream との連携
  QDataStream を使う場合は、waitForReadyRead() や bytesAvailable() を組み合わせて、必要なデータ量（例: quint32 のサイズ、その後のデータのブロックサイズなど）が確実に揃っていることを確認してから operator>>() を使用します。

  // 例: QDataStream でブロックサイズとデータを読み込む場合
  void MyClass::readSocketData()
  {
      QDataStream in(socket);
      in.setVersion(QDataStream::Qt_5_0); // 使用するQtのバージョンに合わせる
  
      // ブロックサイズを読み込む準備ができているか確認
      if (socket->bytesAvailable() < (qint64)sizeof(quint32)) {
          return; // まだ十分なデータがないので待つ
      }
  
      quint32 blockSize;
      in >> blockSize; // ブロックサイズを読み込む
  
      // 実際のデータを読み込む準備ができているか確認
      if (socket->bytesAvailable() < blockSize) {
          return; // まだ十分なデータがないので待つ
      }
  
      QByteArray data;
      data.resize(blockSize);
      in.readRawData(data.data(), blockSize); // 指定されたサイズのデータを読み込む
  
      // 読み込んだデータを処理する
      // ...
  }
  

  上記のように、return; で関数を抜けることで、残りのデータが到着した際に再度 readyRead() が発火し、このスロットが呼び出されることを期待します。

• ループ内で read() を呼び出す
  readyRead() シグナルが発せられたら、while (socket->bytesAvailable() > 0) のようにループを回し、利用可能なすべてのデータを一度に読み込むようにします。

• • 固定長ヘッダー方式
    データ送信時に、まずデータの全長を示す固定長のヘッダー（例: quint32 でバイト数を表す）を送信し、その後に実際のデータを送信するようにします。受信側では、まずヘッダーを読み込み、そのヘッダーが示すバイト数が bytesAvailable() で利用可能になるまで待ってから、残りのデータを読み込みます。
  • セパレータ方式
    データブロックの終わりに特定のセパレータ（例: \n や \r\n）を付加します。受信側では、readLine() や indexOf() を使ってセパレータを探し、データブロックの終端を検出します。

bytesAvailable() は値があるのに read() が空のデータを返す

一般的な原因

• 読み込みバッファのフラッシュ
  非常にまれですが、何らかの理由でQtの内部バッファがフラッシュされた場合、bytesAvailable() が示すデータが利用できなくなることがあります。
• ソケットがすでに閉じられている
  bytesAvailable() を呼び出した直後にソケットがリモートホストによって閉じられた場合、read() を呼び出す頃にはデータが利用できなくなっている可能性があります。

トラブルシューティング

• bytesAvailable() と read() を近くで呼び出す
  bytesAvailable() を確認したら、すぐにデータを読み込むようにコードを記述します。
• エラーシグナルを監視する
  QAbstractSocket::errorOccurred() シグナルを接続し、エラーが発生していないか確認します。特に QAbstractSocket::RemoteHostClosedError が発生していないか確認します。

UIがフリーズする / bytesAvailable() をポーリングしている

一般的な原因

• while (socket->bytesAvailable() == 0) のようなポーリングループ
  Qt はイベント駆動型であり、ソケットからのデータ到着は readyRead() シグナルによって通知されます。UIスレッドで bytesAvailable() が 0 でなくなるまで無限ループで待機すると、イベントループがブロックされ、UIがフリーズします。

トラブルシューティング

• waitForReadyRead() は避ける（UIスレッドでは）
  QAbstractSocket::waitForReadyRead() は、指定された時間だけソケットのデータ到着を同期的に待機する関数です。これはUIスレッドで使用するとUIがフリーズするため、絶対に避けるべきです。どうしても同期的な待ちが必要な場合は、別のスレッドで行うか、非常に短いタイムアウトを設定して使用するしかありませんが、推奨されません。
• 常に readyRead() シグナルを使用する
  bytesAvailable() は readyRead() シグナルのスロット内でのみ使用するようにします。データが到着したら readyRead() が発火し、その中で bytesAvailable() をチェックしてデータを読み込むのが正しい設計です。

qint64 QAbstractSocket::bytesAvailable() は、ソケット通信においてデータが利用可能であるかを確認し、適切な量のデータを読み込むために不可欠な関数です。しかし、その非同期的な性質と、ネットワーク通信の特性を理解せずに使用すると、様々な問題を引き起こす可能性があります。

重要なポイントは以下の通りです。

• エラーシグナルを適切に処理し、デバッグ出力を活用してソケットの状態やbytesAvailable() の値を常に監視することが、問題解決の鍵となります。
• UIスレッドで同期的なデータ待機を行わない。
• データが一度にすべて到着するとは限らないことを理解し、プロトコルを適切に設計する。
• readyRead() シグナルと連携して使用する。

---

qint64 QAbstractSocket::bytesAvailable() は、主に QTcpSocket や QUdpSocket のような具体的なソケットクラスで使われます。ここでは QTcpSocket を例に、データ受信のパターン別に説明します。

基本的なデータ受信（readAll() を使用）

最も単純なケースで、readyRead() シグナルが発せられたら、ソケットに存在するすべてのデータを読み込む例です。

// MyTcpClient.h
#ifndef MYTCPCLIENT_H
#define MYTCPCLIENT_H

#include <QObject>
#include <QTcpSocket>
#include <QDebug> // デバッグ出力用

class MyTcpClient : public QObject
{
    Q_OBJECT
public:
    explicit MyTcpClient(QObject *parent = nullptr);
    void connectToServer(const QString &hostAddress, quint16 port);

signals:
    void dataReceived(const QByteArray &data); // データ受信を通知するシグナル

private slots:
    void onConnected();       // サーバーに接続されたとき
    void onDisconnected();    // サーバーから切断されたとき
    void onReadyRead();       // ソケットにデータが到着したとき（重要！）
    void onError(QAbstractSocket::SocketError socketError); // ソケットエラーが発生したとき

private:
    QTcpSocket *socket;
};

#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::readyRead, this, &MyTcpClient::onReadyRead); // ★ここでデータ到着を検知
    connect(socket, QOverload<QAbstractSocket::SocketError>::of(&QTcpSocket::errorOccurred),
            this, &MyTcpClient::onError);
}

void MyTcpClient::connectToServer(const QString &hostAddress, quint16 port)
{
    qDebug() << "Connecting to server:" << hostAddress << "port:" << port;
    socket->connectToHost(hostAddress, port);
}

void MyTcpClient::onConnected()
{
    qDebug() << "Connected to server!";
}

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

// ★ここが重要: readyRead() シグナルが発せられたとき
void MyTcpClient::onReadyRead()
{
    // bytesAvailable() で、現在読み込み可能なバイト数を確認
    qint64 bytes = socket->bytesAvailable();
    qDebug() << "Data available in buffer:" << bytes << "bytes";

    if (bytes > 0) {
        // availableBytes() で示されたすべてのデータを読み込む
        QByteArray receivedData = socket->readAll();
        qDebug() << "Received data:" << receivedData;

        // 受信したデータをさらに処理するためにシグナルを発行
        emit dataReceived(receivedData);
    }
}

void MyTcpClient::onError(QAbstractSocket::SocketError socketError)
{
    qWarning() << "Socket Error:" << socketError << socket->errorString();
}

解説

• bytes > 0 であれば、socket->readAll() を使って、利用可能なすべてのデータを QByteArray に読み込みます。この readAll() は、bytesAvailable() の戻り値に基づいて内部的に必要なバイト数を読み込んでくれます。
• スロット内で socket->bytesAvailable() を呼び出し、現在読み込み可能なバイト数を取得します。
• onReadyRead() スロットが、QTcpSocket の readyRead() シグナルによって呼び出されます。これは、ソケットの受信バッファに新しいデータが到着したときに発せられるシグナルです。

ヘッダーとペイロードを持つデータの受信（部分的なデータ到着を考慮）

ネットワーク経由では、大きなデータが一度にすべて到着するとは限りません。例えば、最初にデータの全長を示すヘッダーが到着し、その後本体のデータ（ペイロード）が到着するといったシナリオです。この場合、bytesAvailable() は非常に重要になります。

ここでは、「4バイトのデータ長（quint32）＋実際のデータ」というプロトコルを想定します。

// MyTcpClient.h (上記に加えて、必要なメンバ変数を追加)
#ifndef MYTCPCLIENT_H
#define MYTCPCLIENT_H

#include <QObject>
#include <QTcpSocket>
#include <QDataStream> // QDataStream を使用
#include <QDebug>

class MyTcpClient : public QObject
{
    Q_OBJECT
public:
    explicit MyTcpClient(QObject *parent = nullptr);
    void connectToServer(const QString &hostAddress, quint16 port);

signals:
    void dataReceived(const QByteArray &data);

private slots:
    void onConnected();
    void onDisconnected();
    void onReadyRead(); // データ到着
    void onError(QAbstractSocket::SocketError socketError);

private:
    QTcpSocket *socket;
    quint32 nextBlockSize; // 次に読み込むべきデータブロックのサイズを保持
    // または QByteArray buffer; // 受信データを一時的に貯めるバッファ
};

#endif // MYTCPCLIENT_H

// MyTcpClient.cpp (onReadyRead() スロットの変更)
#include "MyTcpClient.h"

MyTcpClient::MyTcpClient(QObject *parent) : QObject(parent), nextBlockSize(0) // 初期化
{
    socket = new QTcpSocket(this);

    // シグナルとスロットの接続（前述と同じ）
    connect(socket, &QTcpSocket::connected, this, &MyTcpClient::onConnected);
    connect(socket, &QTcpSocket::disconnected, this, &MyTcpClient::onDisconnected);
    connect(socket, &QTcpSocket::readyRead, this, &MyTcpClient::onReadyRead);
    connect(socket, QOverload<QAbstractSocket::SocketError>::of(&QTcpSocket::errorOccurred),
            this, &MyTcpClient::onError);
}

// ... connectToServer, onConnected, onDisconnected, onError は同じ

// ★ここが重要: ヘッダーとペイロードの受信
void MyTcpClient::onReadyRead()
{
    QDataStream in(socket);
    in.setVersion(QDataStream::Qt_5_15); // Qt のバージョンに合わせて設定

    // ループを使うことで、複数のデータブロックが一度に到着した場合も処理できる
    while (socket->bytesAvailable() > 0)
    {
        if (nextBlockSize == 0) {
            // まだブロックサイズが不明な場合
            // まずはブロックサイズ（quint32 = 4バイト）を読み込むのに十分なデータがあるか確認
            if (socket->bytesAvailable() < (qint64)sizeof(quint32)) {
                // まだ十分なデータがないので、次回の readyRead() を待つ
                qDebug() << "Waiting for full block size header.";
                return; // ここで関数を抜ける
            }
            // ブロックサイズを読み込む
            in >> nextBlockSize;
            qDebug() << "Next block size expected:" << nextBlockSize << "bytes.";
        }

        // ブロックサイズが判明したら、今度はそのサイズのデータが到着しているか確認
        if (socket->bytesAvailable() < nextBlockSize) {
            // まだブロック全体が到着していないので、次回の readyRead() を待つ
            qDebug() << "Waiting for full data block. Available:" << socket->bytesAvailable() << "Expected:" << nextBlockSize;
            return; // ここで関数を抜ける
        }

        // 全ブロックが到着したので、データを読み込む
        QByteArray receivedData;
        receivedData.resize(nextBlockSize); // 適切なサイズにリサイズ
        in.readRawData(receivedData.data(), nextBlockSize);

        qDebug() << "Received full data block (" << nextBlockSize << " bytes):" << receivedData.toHex(); // 例: Hexで表示

        // 受信したデータを処理する
        emit dataReceived(receivedData);

        // 次のブロックの準備
        nextBlockSize = 0; // 次のブロックサイズは不明にする
    }
}

解説

• データ処理後、nextBlockSize を 0 にリセットし、次のブロックの読み込みに備えます。
• ステップ 2: ペイロードの読み込み
  • nextBlockSize が判明したら、今度は socket->bytesAvailable() < nextBlockSize で、本体のデータがすべて到着しているか確認します。
  • 足りなければ return; して、残りのデータが到着するまで待ちます。
  • 十分なデータがあれば、receivedData.resize(nextBlockSize); で QByteArray を適切なサイズにリサイズし、in.readRawData(receivedData.data(), nextBlockSize); で指定されたバイト数を読み込みます。
• ステップ 1: ヘッダーの読み込み
  • nextBlockSize == 0 の場合、まだブロックサイズが不明です。
  • socket->bytesAvailable() < (qint64)sizeof(quint32) で、ヘッダー（quint32 = 4バイト）を読み込むのに十分なデータがあるか確認します。
  • 足りなければ return; して、残りのデータが到着するまで待ちます（readyRead() が再度発火するのを期待）。
  • 十分なデータがあれば、in >> nextBlockSize; でブロックサイズを読み込みます。
• onReadyRead() 内では、while (socket->bytesAvailable() > 0) ループを使用しています。これは、readyRead() が一度の発行で複数のデータブロックが到着している可能性があるためです。
• nextBlockSize というメンバ変数を使って、次に読み込むべきデータブロックのサイズ（まだ読み込んでいない場合は 0）を管理します。

行指向のデータ受信（readLine() を使用）

HTTPヘッダーや、改行区切りのテキストデータなど、行単位でデータを受信したい場合です。

// MyTcpClient.h (上記に加えて、必要なメンバ変数を追加)
#ifndef MYTCPCLIENT_H
#define MYTCPCLIENT_H

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

class MyTcpClient : public QObject
{
    Q_OBJECT
public:
    explicit MyTcpClient(QObject *parent = nullptr);
    void connectToServer(const QString &hostAddress, quint16 port);

signals:
    void lineReceived(const QByteArray &line); // 行単位のデータ受信を通知

private slots:
    void onConnected();
    void onDisconnected();
    void onReadyRead();
    void onError(QAbstractSocket::SocketError socketError);

private:
    QTcpSocket *socket;
};

#endif // MYTCPCLIENT_H

// MyTcpClient.cpp (onReadyRead() スロットの変更)
#include "MyTcpClient.h"

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

    // シグナルとスロットの接続（前述と同じ）
    connect(socket, &QTcpSocket::connected, this, &MyTcpClient::onConnected);
    connect(socket, &QTaptSocket::disconnected, this, &MyTcpClient::onDisconnected);
    connect(socket, &QTcpSocket::readyRead, this, &MyTcpClient::onReadyRead);
    connect(socket, QOverload<QAbstractSocket::SocketError>::of(&QTcpSocket::errorOccurred),
            this, &MyTcpClient::onError);
}

// ... connectToServer, onConnected, onDisconnected, onError は同じ

// ★ここが重要: 行指向データの受信
void MyTcpClient::onReadyRead()
{
    // bytesAvailable() は直接使わないが、内部で readLine() が利用可能なバイト数を確認する
    // readLine() は改行コード ('\n') またはバッファの終わりまで読み込む
    while (socket->canReadLine()) { // 行が読み込めるか確認
        QByteArray line = socket->readLine();
        qDebug() << "Received line:" << line.trimmed(); // 前後の空白を削除して表示

        emit lineReceived(line); // 受信した行を通知
    }
}

• while (socket->canReadLine()) ループを使うことで、一度に複数の行が到着した場合でも、すべてを処理できます。
• readLine() は、\n が見つかるまで、または指定された最大長までデータを読み込みます。
• canReadLine() は、ソケットの受信バッファに行の終端（\n）があるかどうかを効率的にチェックしてくれます。
• QTcpSocket (および QAbstractSocket の一部) が提供する canReadLine() と readLine() を使用します。
• このケースでは、bytesAvailable() を直接呼び出す必要はほとんどありません。

---

bytesAvailable() は非常に便利ですが、すべてのシナリオでそれだけを使うのが最適とは限りません。特に、より高レベルな抽象化や特定のデータ形式を扱う場合に、別のメソッドが役立ちます。

QAbstractSocket::readAll() の利用

これは最も一般的な代替（または補完）方法です。bytesAvailable() の値を明示的にチェックすることなく、受信バッファにあるすべてのデータを読み込むことができます。

特徴

• 内部的には bytesAvailable() を利用していますが、開発者が直接呼び出す必要はありません。
• readyRead() シグナルが発生した際に、その時点で受信バッファにあるデータを一度にすべて読み込みます。

利点

• データブロックの境界が不明な場合や、連続したバイトストリームとして扱う場合に便利。
• シンプルで記述が少ない。

欠点

• 読み込みバッファに一度に大量のデータが溜まりすぎると、メモリ使用量が増える可能性がある（通常は問題ないが）。
• 大きなデータが分割して到着した場合、部分的なデータしか読み込めない可能性があるため、受信側で「データが揃ったか」を判断するロジックが別途必要になることが多い（例: ヘッダープロトコル）。

使用例

void MyTcpClient::onReadyRead()
{
    // bytesAvailable() を明示的に呼び出さずに、利用可能なすべてのデータを読み込む
    QByteArray receivedData = socket->readAll();
    qDebug() << "Received data:" << receivedData.size() << "bytes:" << receivedData;

    // データに対する後続処理...
}

QAbstractSocket::readLine() および QAbstractSocket::canReadLine() の利用

行指向のテキストプロトコル（例: HTTPヘッダーの一部、シンプルなチャットプロトコルなど）を扱う場合に非常に有効です。

特徴

• readLine(): バッファから次の一行を読み込みます。改行文字を含めるかどうかは指定できます。
• canReadLine(): ソケットの受信バッファに完全な一行（改行文字で終わる）が存在するかどうかを返します。

利点

• bytesAvailable() を使って手動で改行文字を探す手間が省ける。
• データの区切り（行の終端）を自動的に処理してくれる。
• テキストベースのプロトコルで非常に直感的。

欠点

• 大きな行の場合、メモリ使用量に注意。
• バイナリデータや、改行コードを含まないプロトコルには適さない。

使用例

void MyTcpClient::onReadyRead()
{
    while (socket->canReadLine()) { // 読み込める行がある間、ループ
        QByteArray line = socket->readLine();
        qDebug() << "Received line:" << line.trimmed(); // 余分な改行などを削除して表示

        // 受信した行に対する処理...
    }
}

QDataStream を利用した構造化データの読み込み

固定長のヘッダーや、特定のデータ型（quint32、QString など）の送受信を効率的に行う場合に強力です。bytesAvailable() と組み合わせて使われることが多いですが、QDataStream の高レベルなインターフェースがデータパースの複雑さを隠蔽してくれます。

特徴

• ネットワークバイトオーダー変換を自動的に行ってくれる（setByteOrder() で制御可能）。
• QVariant、Qtコンテナクラス、カスタム構造体など、様々なデータ型をシリアライズ/デシリアライズできる。

利点

• bytesAvailable() を使って、必要なデータサイズがバッファにあるかを確認するロジックは必要だが、データ自体のパースは QDataStream が担当してくれる。
• 型安全なデータの送受信が可能。
• データ構造が明確なプロトコルで非常に強力。

欠点

• 非Qtアプリケーションとの互換性が必要な場合は、プロトコル定義を詳細に行う必要がある。
• QDataStream のバージョン管理に注意が必要（送信側と受信側でバージョンを合わせる必要がある）。

使用例
(前述のbytesAvailable()の例で示したように、QDataStreamはbytesAvailable()と組み合わせて使うのが一般的です)

void MyTcpClient::onReadyRead()
{
    QDataStream in(socket);
    in.setVersion(QDataStream::Qt_5_15); // 送信側と合わせる

    if (nextBlockSize == 0) { // 次のブロックサイズがまだ不明な場合
        if (socket->bytesAvailable() < (qint64)sizeof(quint32)) {
            return; // まだヘッダーのデータが足りない
        }
        in >> nextBlockSize; // ヘッダー（ブロックサイズ）を読み込む
    }

    if (socket->bytesAvailable() < nextBlockSize) {
        return; // まだペイロードのデータが足りない
    }

    // ここで、QDataStreamを使って実際のデータを読み込む
    QString message;
    in >> message; // QDataStream が QString を読み込む（エンコーディングも考慮）

    qDebug() << "Received message:" << message;

    nextBlockSize = 0; // 次のブロックの準備
}

固定サイズのバッファに読み込む (read() メソッドの利用)

bytesAvailable() の値に依存せず、常に決まったサイズのデータを読み込みたい場合に QAbstractSocket::read(char *data, qint64 maxSize) を利用します。

特徴

• 返り値として実際に読み込んだバイト数が返されます。
• 指定された最大バイト数だけデータを読み込みます。

利点

• 毎回同じサイズのデータブロックを処理する場合にシンプル。

欠点

• データが部分的に到着した場合の再試行ロジックを開発者自身で実装する必要がある。
• bytesAvailable() を確認せずに呼び出すと、要求したサイズ分のデータがバッファにない場合に、読み込みが短くなる可能性がある。

使用例

void MyTcpClient::onReadyRead()
{
    // 例えば、常に1024バイトのチャンクでデータを処理したい場合
    char buffer[1024];
    qint64 bytesRead = socket->read(buffer, sizeof(buffer));

    if (bytesRead > 0) {
        QByteArray receivedChunk(buffer, bytesRead);
        qDebug() << "Read" << bytesRead << "bytes:" << receivedChunk.toHex();

        // 受信したチャンクに対する処理...
        // 必要に応じて、まだ読み込むべきデータが残っているか bytesAvailable() を確認
        // または、部分受信したデータをバッファに蓄積するロジックを追加
    }
}

QIODevice::setTextModeEnabled() (テキストモードでの改行処理)

QTcpSocket (および QAbstractSocket) は QIODevice を継承しており、テキストモードを有効にできます。

特徴

• readLine() を使用する際に特に便利です。
• socket->setTextModeEnabled(true) を設定すると、Windows (CRLF) と Unix (LF) の改行コードの違いを吸収してくれます。

利点

• クロスプラットフォームでのテキストプロトコル実装の複雑さを軽減。

欠点

• バイナリデータには絶対に使用してはいけません。データが破損する可能性があります。

使用例

MyTcpClient::MyTcpClient(QObject *parent) : QObject(parent)
{
    socket = new QTcpSocket(this);
    socket->setTextModeEnabled(true); // ★ここに設定

    // ... その他の接続
}

// onReadyRead() は readLine() を使う例と同じ

qint64 QAbstractSocket::bytesAvailable() は、ソケットの受信バッファに利用可能なデータ量を正確に知るための基盤となるメソッドです。しかし、実際のプログラミングでは、データの種類（バイナリかテキストか）、プロトコルの形式（固定長、可変長ヘッダー、区切り文字）に応じて、上記のようなより高レベルなメソッドやパターンを適切に選択し、組み合わせることが重要です。