QAbstractSocketで学ぶQtのTCP/UDPプログラミング実践例

2025-05-27

具体的には、以下の値があります。

QAbstractSocket::UnknownSocketType:
- ソケットのタイプが不明であることを示します。通常、エラー状態や初期状態などで使用されます。
QAbstractSocket::SctpSocket:
- これは、SCTP (Stream Control Transmission Protocol) ソケットを表します。
- SCTPは、TCPとUDPのハイブリッドのような性質を持つプロトコルで、信頼性の高いデータ伝送を提供しつつ、マルチストリーミングやマルチホーミングといった高度な機能もサポートします。
- 特定の通信アプリケーションや、複数の接続パスを同時に利用したい場合などに使われることがあります。ただし、TCPやUDPほど一般的に使用されるわけではありません。
QAbstractSocket::UdpSocket:
- これは、UDP (User Datagram Protocol) ソケットを表します。
- UDPは、コネクションレスで、信頼性の保証がないプロトコルです。データはパケット（データグラム）として送信されますが、到達順序や到達の保証はありません。
- リアルタイム通信（ビデオストリーミング、オンラインゲーム、VoIP）など、高速性が重視され、多少のデータ損失が許容されるアプリケーションで主に使用されます。
QAbstractSocket::TcpSocket:
- これは、TCP (Transmission Control Protocol) ソケットを表します。
- TCPは、信頼性の高い、コネクション指向のプロトコルです。データは順番通りに、エラーなく送信されることが保証されます。
- ファイル転送、Webブラウジング (HTTP)、メール (SMTP/POP3/IMAP) など、データの正確な伝送が重要なアプリケーションで主に使用されます。

ここでは、QAbstractSocket（そしてそれを使用するQTcpSocketやQUdpSocket）に関連する一般的なエラーとそのトラブルシューティングについて説明します。エラーの多くは、QAbstractSocket::error()シグナルを通じてQAbstractSocket::SocketError enumとして通知されます。

一般的なエラーとその原因

- 原因
  - サーバーが稼働していない
    接続しようとしているポートでサーバーアプリケーションがListenしていない。
  - ポートが間違っている
    クライアントが間違ったポートに接続しようとしている。
  - ファイアウォール
    サーバー側またはクライアント側のファイアウォールが接続をブロックしている。
  - サーバーが満杯
    サーバーが同時に処理できる接続数の上限に達している。
  - サーバーのIPアドレスが間違っている
    クライアントが間違ったIPアドレスに接続しようとしている。
- 関連するSocketType
  主にTcpSocket。UDPはコネクションレスなので、接続拒否という直接的なエラーは発生しませんが、データが到達しない場合にこの概念に近い状況となります。
QAbstractSocket::HostNotFoundError (ホストが見つからない)
- 原因
  - 間違ったホスト名/IPアドレス
    指定したホスト名やIPアドレスが存在しないか、解決できない。
  - DNS解決の問題
    DNSサーバーが正しく設定されていないか、一時的に利用できない。
  - ネットワーク接続がない
    インターネット接続がない、またはローカルネットワークの問題。
- 関連するSocketType
  TcpSocket, UdpSocketの両方。
QAbstractSocket::RemoteHostClosedError (リモートホストによる接続クローズ)
- 原因
  - サーバーが接続を切断した
    サーバーアプリケーションが明示的に接続を閉じた、またはクラッシュした。
  - ネットワークの問題
    接続中にネットワークが切断された。
  - アイドルタイムアウト
    サーバーが一定時間アイドル状態の接続を自動的に切断する設定になっている。
- 関連するSocketType
  主にTcpSocket。
QAbstractSocket::SocketTimeoutError (ソケット操作のタイムアウト)
- 原因
  - サーバーの応答がない
    接続試行やデータ送受信中にサーバーからの応答がない。
  - ネットワーク遅延
    ネットワークの遅延が大きすぎる。
  - ブロッキング操作
    GUIスレッドなどでブロッキング操作を実行している。Qtのソケットは通常非同期で設計されていますが、waitForConnected()やwaitForReadyRead()のようなブロッキング関数を使用している場合にタイムアウトすることがあります。
- 関連するSocketType
  TcpSocket, UdpSocket。
QAbstractSocket::NetworkError (ネットワークエラー)
- 原因
  - ネットワークケーブルの切断
    物理的なネットワーク接続の問題。
  - ネットワークアダプターの問題
    ネットワークアダプターが正しく機能していない。
  - IPアドレスの競合
    ネットワーク内でIPアドレスの重複がある。
- 関連するSocketType
  TcpSocket, UdpSocket。
QAbstractSocket::SocketAddressNotAvailableError (ソケットアドレスが利用できない)
- 原因
  - バインドするIPアドレスが間違っている
    サーバー側でソケットをバインドしようとしたIPアドレスが、そのホストのネットワークインターフェースに存在しない。
  - ポートが既に使用されている
    指定されたポートが既に他のアプリケーションによって使用されている（特にQUdpSocket::bind()やQTcpServer::listen()の場合）。
- 関連するSocketType
  TcpSocket (サーバー側), UdpSocket (バインド時)。
QAbstractSocket::UnsupportedSocketOperationError (サポートされていないソケット操作)
- 原因
  - OSの制約
    使用しているOSが特定のソケット操作（例：IPv6のサポートがないシステムでのIPv6ソケットの作成）をサポートしていない。
- 関連するSocketType
  状況によりすべてのソケットタイプで発生する可能性があります。

QAbstractSocketのエラーをトラブルシューティングする際には、以下の点に注目します。

QAbstractSocket::error(QAbstractSocket::SocketError socketError) シグナルの利用

最も重要なのは、QAbstractSocketのerrorシグナルをカスタムスロットに接続することです。
このスロット内で、引数として渡されるsocketErrorの値（QAbstractSocket::SocketError enum）を確認し、適切なエラーメッセージを表示したり、ログに出力したりします。
socket->errorString() を呼び出すことで、より詳細なエラーの説明文字列を取得できます。

connect(socket, &QAbstractSocket::error, this, &MyClass::onSocketError);

// ...

void MyClass::onSocketError(QAbstractSocket::SocketError socketError)
{
    qDebug() << "Socket Error:" << socketError;
    qDebug() << "Error String:" << socket->errorString();

    switch (socketError) {
        case QAbstractSocket::ConnectionRefusedError:
            qDebug() << "接続が拒否されました。サーバーが起動しているか、ポートが正しいか確認してください。";
            break;
        case QAbstractSocket::HostNotFoundError:
            qDebug() << "ホストが見つかりません。ホスト名またはIPアドレスを確認してください。";
            break;
        // 他のSocketErrorに対するハンドリング
        default:
            break;
    }
}

QAbstractSocket::stateChanged(QAbstractSocket::SocketState socketState) シグナルの利用
- ソケットの状態が変化するたびに発火するシグナルです。
- QAbstractSocket::UnconnectedState, HostLookupState, ConnectingState, ConnectedState, BoundState, ClosingStateなどの状態を監視することで、ソケットのライフサイクルにおける問題発生箇所を特定しやすくなります。
- 特にConnectingStateからUnconnectedStateに戻る場合や、ClosingStateでスタックする場合などは、何らかの問題が発生している可能性が高いです。
ネットワーク設定の確認
- ファイアウォール
  OS（Windows Defender, macOS Firewall, Linux iptables/ufw）やルーターのファイアウォール設定を確認し、通信を許可するように設定されているか確認します。
- ポートの開放
  サーバーアプリケーションが使用するポートが外部からアクセス可能になっているか確認します（特にサーバーアプリケーションを公開する場合）。
- IPアドレスとポート
  クライアントとサーバーで設定しているIPアドレスとポート番号が一致しているか、誤りがないか再確認します。
- DNS設定
  ホスト名を使用している場合は、DNS解決が正しく行われているかを確認します（pingコマンドなどで確認できます）。
サーバー/クライアントのログ出力
- サーバーアプリケーションとクライアントアプリケーションの両方で、詳細なログを出力するようにします。これにより、どちらの側で問題が発生しているのか、具体的なエラーメッセージは何かを特定できます。
ネットワークモニタリングツール
- Wiresharkやtcpdumpなどのネットワークパケットアナライザを使用して、実際のネットワークトラフィックをキャプチャし、通信がどのように行われているか（または行われていないか）を詳細に分析します。これにより、どのフェーズで通信が途絶えているのか、予期しないパケットが送信されていないかなどを確認できます。
waitFor...() 関数（ブロッキングモード）の使用は慎重に
- QAbstractSocket::waitForConnected(), waitForReadyRead(), waitForBytesWritten() などの関数は、GUIアプリケーションのメインスレッドで使用するとUIのフリーズを引き起こす可能性があります。これらの関数は、バックグラウンドスレッドやノンブロッキングモードの例外的な状況でのみ使用し、通常はシグナル/スロットによる非同期処理を推奨します。
QTcpServer (サーバー側) の設定
- QTcpServer::listen()が成功しているか確認します。
- QTcpServer::newConnection()シグナルが正しく接続され、新しいソケットが受け入れられているか確認します。

以下に、QAbstractSocket::SocketType に関連するプログラミング例を、TCPクライアント/サーバーとUDP送受信の形で説明します。

TCP ソケットの例 (QTcpSocket を使用)

TCPはコネクション指向で信頼性の高い通信を提供します。データの順序性や到達保証が必要な場合に使用します。

TCPサーバー (簡単なエコーサーバー)

// tcpserver.h
#ifndef TCPSERVER_H
#define TCPSERVER_H

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

class TcpServer : public QObject
{
    Q_OBJECT
public:
    explicit TcpServer(QObject *parent = nullptr) : QObject(parent)
    {
        tcpServer = new QTcpServer(this);

        // 新しい接続が利用可能になったら newConnection() シグナルが発火
        connect(tcpServer, &QTcpServer::newConnection, this, &TcpServer::onNewConnection);

        // サーバーがListenを開始
        if (!tcpServer->listen(QHostAddress::Any, 12345)) { // 任意のIPアドレス、ポート12345
            qDebug() << "サーバーのListenに失敗しました:" << tcpServer->errorString();
        } else {
            qDebug() << "サーバーがポート" << tcpServer->serverPort() << "でListenを開始しました。";
        }
    }

private slots:
    void onNewConnection()
    {
        qDebug() << "新しいクライアントが接続しました！";
        QTcpSocket *clientSocket = tcpServer->nextPendingConnection(); // 接続されたソケットを取得

        // クライアントからのデータ受信時に readyRead() シグナルが発火
        connect(clientSocket, &QTcpSocket::readyRead, this, &TcpServer::onReadyRead);
        // クライアントが切断したら disconnected() シグナルが発火
        connect(clientSocket, &QTcpSocket::disconnected, clientSocket, &QTcpSocket::deleteLater); // ソケットを自動削除
        connect(clientSocket, &QTcpSocket::disconnected, this, &TcpServer::onDisconnected);
        // エラー発生時に errorOccurred() シグナルが発火
        connect(clientSocket, &QTcpSocket::errorOccurred, this, &TcpServer::onSocketError);

        qDebug() << "接続クライアントIP:" << clientSocket->peerAddress().toString();
        qDebug() << "接続クライアントPort:" << clientSocket->peerPort();
    }

    void onReadyRead()
    {
        QTcpSocket *clientSocket = qobject_cast<QTcpSocket*>(sender());
        if (!clientSocket)
            return;

        QByteArray data = clientSocket->readAll(); // 受信したデータを全て読み込む
        qDebug() << "サーバーがデータを受信しました:" << data;

        clientSocket->write("Echo: " + data); // 受信したデータを「Echo: 」を付けて返信
        clientSocket->flush(); // 強制的に書き込み
        qDebug() << "サーバーがデータEchoを送信しました:" << data;
    }

    void onDisconnected()
    {
        QTcpSocket *clientSocket = qobject_cast<QTcpSocket*>(sender());
        if (!clientSocket)
            return;
        qDebug() << "クライアントが切断しました:" << clientSocket->peerAddress().toString() << ":" << clientSocket->peerPort();
    }

    void onSocketError(QAbstractSocket::SocketError socketError)
    {
        QTcpSocket *clientSocket = qobject_cast<QTcpSocket*>(sender());
        if (!clientSocket)
            return;

        qDebug() << "ソケットエラーが発生しました:" << clientSocket->errorString() << "(" << socketError << ")";
    }

private:
    QTcpServer *tcpServer;
};

#endif // TCPSERVER_H

TCPクライアント

// tcpclient.h
#ifndef TCPCLIENT_H
#define TCPCLIENT_H

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

class TcpClient : public QObject
{
    Q_OBJECT
public:
    explicit TcpClient(QObject *parent = nullptr) : QObject(parent)
    {
        tcpSocket = new QTcpSocket(this);

        // 接続が確立したら connected() シグナルが発火
        connect(tcpSocket, &QTcpSocket::connected, this, &TcpClient::onConnected);
        // データが利用可能になったら readyRead() シグナルが発火
        connect(tcpSocket, &QTcpSocket::readyRead, this, &TcpClient::onReadyRead);
        // 切断されたら disconnected() シグナルが発火
        connect(tcpSocket, &QTcpSocket::disconnected, this, &TcpClient::onDisconnected);
        // エラー発生時に errorOccurred() シグナルが発火
        connect(tcpSocket, &QTcpSocket::errorOccurred, this, &TcpClient::onSocketError);

        // 定期的にメッセージを送信するタイマー（任意）
        sendTimer = new QTimer(this);
        connect(sendTimer, &QTimer::timeout, this, &TcpClient::sendMessage);
    }

    void connectToServer(const QString &hostAddress, quint16 port)
    {
        qDebug() << "サーバーに接続を試みています...";
        tcpSocket->connectToHost(hostAddress, port); // サーバーに接続
        // Note: connectToHost は非同期操作なので、接続完了まで待つ必要はありません。
        // connected() シグナルで接続完了を処理します。
    }

    void disconnectFromServer()
    {
        qDebug() << "サーバーから切断しています...";
        tcpSocket->disconnectFromHost();
        sendTimer->stop();
    }

    void sendMessage()
    {
        if (tcpSocket->state() == QAbstractSocket::ConnectedState) {
            QString message = "Hello from Client!";
            tcpSocket->write(message.toUtf8()); // UTF-8でバイト配列に変換して送信
            tcpSocket->flush();
            qDebug() << "クライアントがメッセージを送信しました:" << message;
        } else {
            qDebug() << "ソケットが接続されていません。メッセージを送信できません。";
        }
    }

private slots:
    void onConnected()
    {
        qDebug() << "サーバーに接続しました！";
        sendTimer->start(2000); // 2秒ごとにメッセージを送信
    }

    void onReadyRead()
    {
        QByteArray data = tcpSocket->readAll();
        qDebug() << "クライアントがデータを受信しました:" << data;
    }

    void onDisconnected()
    {
        qDebug() << "サーバーから切断されました。";
        sendTimer->stop();
    }

    void onSocketError(QAbstractSocket::SocketError socketError)
    {
        qDebug() << "ソケットエラーが発生しました:" << tcpSocket->errorString() << "(" << socketError << ")";
        sendTimer->stop();
    }

private:
    QTcpSocket *tcpSocket;
    QTimer *sendTimer;
};

#endif // TCPCLIENT_H

UDP ソケットの例 (QUdpSocket を使用)

UDPはコネクションレスで、信頼性の保証がない通信を提供します。リアルタイム性やオーバーヘッドの低減が重要な場合に使用します。

UDP送受信 (ブロードキャストと受信)

// udpsocketmanager.h
#ifndef UDPSOCKETMANAGER_H
#define UDPSOCKETMANAGER_H

#include <QObject>
#include <QUdpSocket>
#include <QHostAddress>
#include <QDebug>
#include <QTimer>

class UdpSocketManager : public QObject
{
    Q_OBJECT
public:
    explicit UdpSocketManager(QObject *parent = nullptr) : QObject(parent)
    {
        udpSocket = new QUdpSocket(this);

        // ポートにバインドして受信を開始
        // QHostAddress::AnyIPv4 は IPv4 アドレス全てから受信を許可
        if (!udpSocket->bind(QHostAddress::AnyIPv4, 45454)) { // ポート45454
            qDebug() << "UDPソケットのバインドに失敗しました:" << udpSocket->errorString();
        } else {
            qDebug() << "UDPソケットがポート" << udpSocket->localPort() << "で受信を開始しました。";
        }

        // データグラムが利用可能になったら readyRead() シグナルが発火
        connect(udpSocket, &QUdpSocket::readyRead, this, &UdpSocketManager::readPendingDatagrams);
        // エラー発生時に errorOccurred() シグナルが発火
        connect(udpSocket, &QUdpSocket::errorOccurred, this, &UdpSocketManager::onSocketError);

        // 定期的にブロードキャストメッセージを送信するタイマー
        sendTimer = new QTimer(this);
        connect(sendTimer, &QTimer::timeout, this, &UdpSocketManager::sendBroadcastDatagram);
        sendTimer->start(3000); // 3秒ごとにブロードキャスト
    }

public slots:
    void sendBroadcastDatagram()
    {
        QByteArray datagram = "Hello from UDP Broadcast!";
        // QHostAddress::Broadcast は IPv4 ブロードキャストアドレス
        qint64 bytes = udpSocket->writeDatagram(datagram.data(), datagram.size(), QHostAddress::Broadcast, 45454);
        if (bytes == -1) {
            qDebug() << "ブロードキャストデータグラムの送信に失敗しました:" << udpSocket->errorString();
        } else {
            qDebug() << "UDPブロードキャストデータグラムを送信しました:" << datagram;
        }
    }

private slots:
    void readPendingDatagrams()
    {
        while (udpSocket->hasPendingDatagrams()) { // 受信待機中のデータグラムがあるか確認
            QByteArray datagram;
            datagram.resize(udpSocket->pendingDatagramSize()); // データグラムのサイズに合わせてバッファをリサイズ

            QHostAddress senderAddress;
            quint16 senderPort;

            // データグラムを読み込み、送信元アドレスとポートを取得
            udpSocket->readDatagram(datagram.data(), datagram.size(), &senderAddress, &senderPort);

            qDebug() << "UDPデータグラムを受信しました:";
            qDebug() << "  送信元アドレス:" << senderAddress.toString();
            qDebug() << "  送信元ポート:" << senderPort;
            qDebug() << "  データ:" << datagram;
        }
    }

    void onSocketError(QAbstractSocket::SocketError socketError)
    {
        qDebug() << "ソケットエラーが発生しました:" << udpSocket->errorString() << "(" << socketError << ")";
    }

private:
    QUdpSocket *udpSocket;
    QTimer *sendTimer;
};

#endif // UDPSOCKETMANAGER_H

main.cpp (両方のソケットタイプをテストするためのメイン関数)

#include <QCoreApplication>
#include "tcpserver.h"
#include "tcpclient.h"
#include "udpsocketmanager.h"

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

    // TCPサーバーのインスタンス化 (サーバーとして動作)
    TcpServer server;

    // TCPクライアントのインスタンス化 (クライアントとして動作)
    TcpClient client;
    client.connectToServer("127.0.0.1", 12345); // localhost のポート12345に接続

    // UDPソケットマネージャーのインスタンス化 (送受信を兼ねる)
    UdpSocketManager udpManager;

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

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

これらのコードを実行するには、Qtプロジェクトファイル（.pro）にnetworkモジュールを追加する必要があります。

QT += core network

SOURCES += \
    main.cpp \
    tcpserver.cpp \
    tcpclient.cpp \
    udpsocketmanager.cpp

HEADERS += \
    tcpserver.h \
    tcpclient.h \
    udpsocketmanager.h

QAbstractSocket::SocketTypeの役割
- 上記の例では、QTcpSocketとQUdpSocketという特定のサブクラスを直接使用しています。これらのサブクラスは、それぞれのソケットタイプ（TcpSocketまたはUdpSocket）に特化した機能をラップしています。
- したがって、通常アプリケーションコードでQAbstractSocket::SocketTypeを直接操作することはあまりありません。
- しかし、QAbstractSocketのコンストラクタにはQAbstractSocket::SocketTypeを引数として渡すオーバーロードがあり、より汎用的なソケットを生成したい場合に使用できます。（例: new QAbstractSocket(QAbstractSocket::TcpSocket, this);）
- また、socket->socketType()を呼び出すことで、現在のソケットがTCPかUDPかを確認することができます。
QUdpSocket (UDP)
- QUdpSocket はQAbstractSocket::UdpSocket型として内部的に構築されます。
- UDPはコネクションレスなので、接続の概念がありません。
- bind()メソッドで特定のポートにバインドすることで、そのポートからのデータグラムを受信できるようになります。
- データの送信にはwriteDatagram(data, hostAddress, port)を使用し、宛先を明示的に指定します。
- データの受信はreadyRead()シグナルで検出し、readDatagram()で送信元情報とともにデータグラムを読み取ります。
- この例ではブロードキャストアドレス (QHostAddress::Broadcast) を使用して、ネットワーク上のすべてのデバイスにデータグラムを送信しています。
- QTcpSocket はQAbstractSocket::TcpSocket型として内部的に構築されます。
- サーバー側
  QTcpServerを使用して接続を待ち受けます。newConnection()シグナルで新しいクライアント接続を検出し、その接続を表すQTcpSocketオブジェクトを取得します。
- クライアント側
  QTcpSocket::connectToHost()を呼び出してサーバーに接続を試みます。
- データ送受信はwrite()とreadAll()（またはread()、readLine()など）で行います。
- connected()、disconnected()、readyRead()、errorOccurred()などのシグナルを使用して、非同期的にイベントを処理します。

QtのQAbstractSocket::SocketTypeは、ネットワークプログラミングにおいてTCPソケットとUDPソケットのどちらを使用するかを区別するための基本的な概念です。Qtのネットワークモジュール内でこのenumを直接「代替」する方法というよりは、Qtのネットワーク機能を利用せずに、あるいはより低レベルなアプローチで同様のネットワーク通信をC++で実装する方法、またはQtの他のネットワーク関連機能を利用する方法を指すと考えられます。

以下に、QtのQAbstractSocket::SocketTypeが提供する機能の代替となるプログラミング方法をいくつか説明します。

QTcpSocket / QUdpSocket の直接使用 (Qtの標準的なアプローチ)

これは代替というよりは、QAbstractSocket::SocketTypeの最も一般的な利用方法です。前回の説明で示したように、通常はQAbstractSocketの直接のサブクラスであるQTcpSocketやQUdpSocketを直接インスタンス化します。これにより、暗黙的に適切なSocketTypeが選択され、開発者はソケットの具体的な種類を意識せずに、高レベルのAPIを使用できます。

利点

イベントループとの統合が容易。
エラーハンドリング、プロキシサポート、SSL/TLSサポート（QSslSocket）などが充実している。
クロスプラットフォーム対応。
Qtのシグナル/スロットメカニズムによる非同期処理が容易。

欠点

Qtフレームワークへの依存。

QAbstractSocket のコンストラクタで SocketType を指定してインスタンス化

これはあまり一般的ではありませんが、QAbstractSocketのコンストラクタにSocketTypeを渡してインスタンス化することも可能です。その後、QAbstractSocketの共通インターフェースを通じて操作します。

#include <QAbstractSocket>
#include <QDebug>

// ... どこかのクラスのメソッド内で
QAbstractSocket *socket = new QAbstractSocket(QAbstractSocket::TcpSocket, this);
// または
// QAbstractSocket *socket = new QAbstractSocket(QAbstractSocket::UdpSocket, this);

// TCPソケットの場合
socket->connectToHost("example.com", 80);

// UDPソケットの場合
// socket->bind(QHostAddress::Any, 12345);
// socket->writeDatagram("Hello", QHostAddress::Broadcast, 12345);

// シグナル/スロット接続など、QTcpSocket/QUdpSocketと同様に扱える
connect(socket, &QAbstractSocket::connected, [](){ qDebug() << "Connected!"; });
connect(socket, &QAbstractSocket::readyRead, [&](){ qDebug() << "Data available:" << socket->readAll(); });

// QAbstractSocket::socketType() で現在のソケットタイプを確認できる
if (socket->socketType() == QAbstractSocket::TcpSocket) {
    qDebug() << "これはTCPソケットです。";
} else if (socket->socketType() == QAbstractSocket::UdpSocket) {
    qDebug() << "これはUDPソケットです。";
}

利点

QTcpSocketやQUdpSocketのサブクラス化が不要な場合に、直接QAbstractSocketを使用できる。
ソケットの型を実行時に動的に決定したい場合に、共通のポインタで扱える。

欠点

特定のソケットタイプに特化した機能（例: QTcpServerによる接続の受け入れ）は、それぞれのサブクラスを使う必要がある。

ネイティブソケットAPI (OS固有のAPI) の直接使用

Qtを使用せず、C++で直接OSが提供するソケットAPI（例: WindowsのWinsock2、Unix/LinuxのBerkeley Sockets）を呼び出す方法です。

Unix/Linux/macOS
Berkeley Sockets API (例: socket(), connect(), bind(), listen(), accept(), send(), recv())
Windows
Winsock2 API (例: socket(), connect(), bind(), listen(), accept(), send(), recv())

利点

パフォーマンスがクリティカルな部分で、Qtの抽象化レイヤーを介さない分、わずかな最適化の余地があるかもしれない。
OSのネットワーク機能に直接アクセスできるため、非常に細かい制御が可能。
Qtへの依存をなくせるため、非常に軽量なアプリケーションを作成できる。

欠点

イベントループとの統合も自力で行う必要がある（Qtのイベントループに統合するのは困難）。
ネットワークの複雑な処理
SSL/TLS、プロキシ、DNS解決などを自力で実装するか、他のライブラリに依存する必要がある。
煩雑なコード
エラーチェック、バッファ管理、非同期I/O（特にWindowsのIOCPやLinuxのepoll/kqueueなどを使用する場合）など、多くの低レベルな詳細を開発者が管理する必要がある。
プラットフォーム非依存性の喪失
WindowsとUnix系OSでコードを書き分ける必要がある。

例 (非常に簡略化されたTCPクライアントの概念、実際にはエラー処理などが必要)

#include <iostream>
#include <string>

#ifdef _WIN32
#include <winsock2.h>
#pragma comment(lib, "ws2_32.lib")
#else
#include <sys/socket.h>
#include <arpa/inet.h>
#include <unistd.h> // close()
#endif

void nativeTcpClient(const std::string& host, int port) {
#ifdef _WIN32
    WSADATA wsaData;
    if (WSAStartup(MAKEWORD(2, 2), &wsaData) != 0) {
        std::cerr << "WSAStartup failed." << std::endl;
        return;
    }
#endif

    int sock = socket(AF_INET, SOCK_STREAM, 0); // TCPソケット
    if (sock == -1) {
        std::cerr << "ソケットの作成に失敗しました。" << std::endl;
#ifdef _WIN32
        WSACleanup();
#endif
        return;
    }

    sockaddr_in serverAddress;
    serverAddress.sin_family = AF_INET;
    serverAddress.sin_port = htons(port);
#ifdef _WIN32
    serverAddress.sin_addr.S_un.S_addr = inet_addr(host.c_str());
#else
    inet_pton(AF_INET, host.c_str(), &serverAddress.sin_addr);
#endif

    if (connect(sock, (struct sockaddr*)&serverAddress, sizeof(serverAddress)) == -1) {
        std::cerr << "接続に失敗しました。" << std::endl;
#ifdef _WIN32
        closesocket(sock);
        WSACleanup();
#else
        close(sock);
#endif
        return;
    }

    std::cout << "サーバーに接続しました。" << std::endl;

    std::string message = "Hello from Native TCP Client!";
#ifdef _WIN32
    send(sock, message.c_str(), message.length(), 0);
#else
    send(sock, message.c_str(), message.length(), 0);
#endif
    std::cout << "メッセージを送信しました: " << message << std::endl;

    char buffer[1024] = {0};
#ifdef _WIN32
    int bytesRead = recv(sock, buffer, sizeof(buffer) - 1, 0);
#else
    ssize_t bytesRead = recv(sock, buffer, sizeof(buffer) - 1, 0);
#endif
    if (bytesRead > 0) {
        buffer[bytesRead] = '\0';
        std::cout << "データを受信しました: " << buffer << std::endl;
    }

#ifdef _WIN32
    closesocket(sock);
    WSACleanup();
#else
    close(sock);
#endif
}

// int main() {
//     nativeTcpClient("127.0.0.1", 12345);
//     return 0;
// }

既に存在するネイティブソケットディスクリプタ（OSから取得したソケットハンドル）をQtのQAbstractSocketオブジェクトに「ラップ」する方法です。これは、特定の低レベルなソケットオプションを設定する必要がある場合や、他のライブラリで作成されたソケットをQtのイベントループに統合したい場合に便利です。

#include <QAbstractSocket>
#include <QDebug>

#ifdef _WIN32
#include <winsock2.h>
#pragma comment(lib, "ws2_32.lib")
#else
#include <sys/socket.h>
#include <arpa/inet.h>
#include <unistd.h>
#endif

// 仮のネイティブソケット作成関数
qintptr createNativeTcpSocket() {
#ifdef _WIN32
    WSADATA wsaData;
    if (WSAStartup(MAKEWORD(2, 2), &wsaData) != 0) {
        qDebug() << "WSAStartup failed.";
        return -1;
    }
#endif
    qintptr sock = socket(AF_INET, SOCK_STREAM, 0);
    if (sock == -1) {
        qDebug() << "ネイティブソケットの作成に失敗しました。";
#ifdef _WIN32
        WSACleanup();
#endif
    }
    return sock;
}

// ... どこかのクラスのメソッド内で
void myClass::useWrappedSocket() {
    qintptr nativeSocketDescriptor = createNativeTcpSocket();
    if (nativeSocketDescriptor == -1) {
        return;
    }

    QTcpSocket *tcpSocket = new QTcpSocket(this);
    // 既存のネイティブソケットディスクリプタをラップ
    if (!tcpSocket->setSocketDescriptor(nativeSocketDescriptor)) {
        qDebug() << "ソケットディスクリプタの設定に失敗しました:" << tcpSocket->errorString();
#ifdef _WIN32
        closesocket(nativeSocketDescriptor);
        WSACleanup();
#else
        close(nativeSocketDescriptor);
#endif
        delete tcpSocket;
        return;
    }

    qDebug() << "ネイティブソケットをQtソケットでラップしました。";

    // 以降は通常のQTcpSocketとして使用可能
    connect(tcpSocket, &QTcpSocket::readyRead, [tcpSocket](){
        qDebug() << "受信データ:" << tcpSocket->readAll();
    });
    // connectToHostは通常は不要（ネイティブソケットが既に接続されている前提）
    // write() や close() などはQtのAPIを使用
    tcpSocket->write("Hello from Wrapped Socket!");
    tcpSocket->flush();
}

利点

既存のC++ネットワークコードをQtアプリケーションに徐々に移行する場合に有用。
低レベルなソケット制御とQtの高レベルなイベントループ統合を両立できる。

欠点

プラットフォーム固有のコードが一部残る。
ネイティブソケットのライフサイクル管理とQtソケットのライフサイクル管理を適切に調整する必要がある。

Qtに依存しない、またはQtとは異なる設計思想を持つC++ネットワークライブラリを使用する方法です。

cpp-netlib
モダンC++のイディオムを取り入れたHTTP/HTTPSクライアント・サーバーライブラリ。
POCO C++ Libraries
ネットワーク、データアクセス、XML処理など、多岐にわたる機能を提供する包括的なライブラリ。
WebSocket++ / uWS
WebSocket通信に特化したライブラリ。
libcurl
HTTP/HTTPSなどの高レベルなプロトコルを扱うクライアントライブラリとして広く使われています。FTP、SMTPなどもサポートします。
Boost.Asio
C++標準ライブラリの拡張を目指すBoostライブラリの一部。非同期I/Oに特化しており、非常に柔軟で強力です。QtのQAbstractSocketと同様に、TCP/UDPソケットを抽象化し、非同期操作を提供します。

利点

特定の用途に特化したライブラリの場合、その機能において非常に強力な解決策を提供できる。
Qtに依存しないため、フレームワークの選択肢が広がる。

欠点

学習コスト。
Qtアプリケーション内で使用する場合、Qtのイベントループやオブジェクトモデルとの統合に追加のコードが必要になる場合がある（例: Boost.AsioのI/OサービスをQtのイベントループと連携させる）。

QAbstractSocket::SocketTypeの「代替方法」と考える場合、それはQtの標準的なネットワークモジュールを使用しない、あるいはより低レベルな制御を行う方法を意味します。

他のC++ライブラリを使用する場合
Boost.Asioなどの非同期I/Oライブラリは強力な代替となり得ますが、Qtとの統合を考慮する必要があります。
低レベルな制御が必要な場合
ネイティブソケットAPIを直接使用するか、QAbstractSocket::setSocketDescriptor()でラップする。ただし、プラットフォーム非依存性やコードの複雑さが増します。
最も一般的で推奨されるアプローチ
QTcpSocketやQUdpSocketを直接使用する。これにより、Qtのメリットを最大限に活用できます。