Qt 网络编程 01：TCP 客户端与服务端（第一天）

# 控制台版只需要 network
QT += network

# GUI 版还需要 core gui widgets
QT += core gui network
greaterThan(QT_MAJOR_VERSION, 4): QT += widgets

// TcpSocket.h
#include <QObject>
#include <QTcpServer>
#include <QTcpSocket>

class TcpSocket : public QObject
{
    Q_OBJECT
public:
    explicit TcpSocket(QObject *parent = nullptr);
private:
    QTcpSocket *socket;
};

// TcpSocket.cpp
#include "TcpSocket.h"
#include <QDebug>

TcpSocket::TcpSocket(QObject *parent)
    : QObject{parent}
{
    // 1. 创建 socket 对象
    socket = new QTcpSocket(this);

    // 2. 连接服务器（异步！调用后立刻返回，不一定已连接）
    socket->connectToHost("127.0.0.1", 8080);

    // 3. 连接成功时触发
    connect(socket, &QTcpSocket::connected, this, [this](){
        qDebug() << "连接服务器成功";
        // 连接成功后主动发一条消息
        socket->write("Hello Server!");
    });

    // 4. 收到数据时触发
    connect(socket, &QTcpSocket::readyRead, this, [this](){
        QByteArray data = socket->readAll();
        qDebug() << "收到服务器:" << data;
    });
}

// main.cpp
#include <QCoreApplication>
#include <TcpSocket.h>

int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);
    TcpSocket socket;          // 对象必须存活，信号槽才有效
    return QCoreApplication::exec();   // 进入事件循环，等信号
}

// TcpServer.h
#include <QObject>
#include <QTcpServer>
#include <QTcpSocket>
#include <QList>

class TcpServer : public QObject
{
    Q_OBJECT
public:
    explicit TcpServer(QObject *parent = nullptr);
private:
    QTcpServer * server = nullptr;
    QList<QTcpSocket*> clients;   // 所有已连接客户端的列表
};

// TcpServer.cpp
#include "TcpServer.h"
#include <QDebug>

TcpServer::TcpServer(QObject *parent)
    : QObject{parent}
{
    // 1. 创建服务器对象
    server = new QTcpServer(this);

    // 2. 监听端口 8080
    server->listen(QHostAddress::Any, 8080);
    qDebug() << "服务器启动，监听 8080 端口";

    // 3. 有客户端连接时触发
    connect(server, &QTcpServer::newConnection, this, [this](){
        // 4. 获取客户端 socket，并存入列表
        QTcpSocket* client = server->nextPendingConnection();
        clients.append(client);
        qDebug() << "客户端已连接，当前连接数:" << clients.size();

        // 5. 监听客户端发来的数据
        connect(client, &QTcpSocket::readyRead, this, [this, client](){
            QByteArray data = client->readAll();
            qDebug() << "收到客户端:" << data;

            // 6. 广播给所有客户端
            for (auto s : clients) {
                s->write(data);
            }
        });

        // 7. 客户端断开时，从列表移除并释放
        connect(client, &QTcpSocket::disconnected, this, [this, client](){
            qDebug() << "客户端已断开，当前连接数:" << clients.size() - 1;
            clients.removeOne(client);
            client->deleteLater();    // 安全释放（等当前事件循环处理完）
        });
    });
}

// widget.h（节选）
#include <QWidget>
#include <QTcpServer>
#include <QTcpSocket>

class Widget : public QWidget
{
    Q_OBJECT
public:
    Widget(QWidget *parent = nullptr);
    ~Widget();

private:
    Ui::Widget *ui;
    QTcpSocket *tcpSocket;

private slots:
    void connected_Slot();
    void disconnected_Slot();
    void error_Slot(QAbstractSocket::SocketError);
    void readyRead_Slot();
    void on_openBt_clicked();
    void on_closeBt_clicked();
    void on_sendBt_clicked();
};

// widget.cpp（节选）
Widget::Widget(QWidget *parent)
    : QWidget(parent), ui(new Ui::Widget)
{
    ui->setupUi(this);
    setWindowTitle("Client");

    tcpSocket = new QTcpSocket(this);

    connect(tcpSocket, SIGNAL(connected()), this, SLOT(connected_Slot()));
    connect(tcpSocket, SIGNAL(disconnected()), this, SLOT(disconnected_Slot()));
    connect(tcpSocket, SIGNAL(errorOccurred(QAbstractSocket::SocketError)),
            this, SLOT(error_Slot(QAbstractSocket::SocketError)));
}

void Widget::connected_Slot()
{
    ui->recvEdit->appendPlainText("已连接服务器");
    connect(tcpSocket, SIGNAL(readyRead()), this, SLOT(readyRead_Slot()));
}

void Widget::disconnected_Slot()
{
    ui->recvEdit->appendPlainText("已断开连接");
}

void Widget::error_Slot(QAbstractSocket::SocketError)
{
    ui->recvEdit->appendPlainText("连接失败: " + tcpSocket->errorString());
}

void Widget::readyRead_Slot()
{
    ui->recvEdit->appendPlainText(tcpSocket->readAll());
}

void Widget::on_openBt_clicked()
{
    tcpSocket->connectToHost(ui->IPEdit->text(), ui->portEdit->text().toUInt());
}

void Widget::on_closeBt_clicked()
{
    tcpSocket->close();
}

void Widget::on_sendBt_clicked()
{
    if (tcpSocket->state() != QAbstractSocket::ConnectedState) {
        ui->recvEdit->appendPlainText("错误：未连接服务器");
        return;
    }
    tcpSocket->write(ui->sendEdit->text().toUtf8());
    ui->sendEdit->clear();
}

// widget.cpp（节选）
Widget::Widget(QWidget *parent)
    : QWidget(parent), ui(new Ui::Widget)
{
    ui->setupUi(this);
    setWindowTitle("Server");

    tcpServer = new QTcpServer(this);
    tcpSocket = new QTcpSocket(this);

    connect(tcpServer, SIGNAL(newConnection()), this, SLOT(newConnection_Slot()));
}

void Widget::newConnection_Slot()
{
    tcpSocket = tcpServer->nextPendingConnection();
    connect(tcpSocket, SIGNAL(readyRead()), this, SLOT(readyRead_Slot()));
}

void Widget::readyRead_Slot()
{
    QString buf;
    buf = tcpSocket->readAll();
    ui->recvEdit->appendPlainText(buf);
}

void Widget::on_openBt_clicked()
{
    tcpServer->listen(QHostAddress::Any, ui->portEdit->text().toUInt());
}

void Widget::on_closeBt_clicked()
{
    tcpServer->close();      // 停止监听
}

void Widget::on_sendBt_clicked()
{
    if (!tcpSocket || tcpSocket->state() != QAbstractSocket::ConnectedState) {
        ui->recvEdit->appendPlainText("错误：没有客户端连接");
        return;
    }
    tcpSocket->write(ui->sendEdit->text().toUtf8());
    ui->sendEdit->clear();
}

// ClientConnection.h —— 每个客户端一个对象
#ifndef CLIENTCONNECTION_H
#define CLIENTCONNECTION_H

#include <QObject>
#include <QTcpSocket>

class ClientConnection : public QObject
{
    Q_OBJECT
public:
    explicit ClientConnection(QTcpSocket *sock, QObject *parent = nullptr)
        : QObject(parent), m_socket(sock)
    {
        sock->setParent(this);   // 交给对象树管理，断开时随本对象一起销毁

        // 构造函数里就装好监听，拿到 socket 即生效
        connect(sock, &QTcpSocket::readyRead, this, [this](){
            QByteArray data = m_socket->readAll();
            handleData(data);
        });

        connect(sock, &QTcpSocket::disconnected, this, [this](){
            emit disconnected(this);   // 通知服务器把我从列表移除
        });
    }

    void send(const QByteArray &data) { m_socket->write(data); }
    QString peerAddress() const { return m_socket->peerAddress().toString(); }

signals:
    void disconnected(ClientConnection*);   // 携带自身指针，方便服务器删除

private:
    void handleData(const QByteArray &data)
    {
        // 业务逻辑：解析协议、处理消息……（阶段二学粘包后再完善）
    }

    QTcpSocket *m_socket;
};

#endif // CLIENTCONNECTION_H

// Server.cpp —— 服务器只用管"连接与列表"
#include "ClientConnection.h"
#include <QList>

class Server : public QObject
{
    Q_OBJECT
public:
    explicit Server(QObject *parent = nullptr)
        : QObject(parent)
    {
        m_server = new QTcpServer(this);
        m_server->listen(QHostAddress::Any, 8080);

        connect(m_server, &QTcpServer::newConnection, this, [this](){
            QTcpSocket *sock = m_server->nextPendingConnection();
            ClientConnection *conn = new ClientConnection(sock, this);
            m_conns.append(conn);   // 列表只管对象本身，不管内部 socket

            connect(conn, &ClientConnection::disconnected, this, [this](ClientConnection *c){
                m_conns.removeOne(c);
                c->deleteLater();
            });
        });
    }

private:
    QTcpServer *m_server;
    QList<ClientConnection*> m_conns;   // 存的是连接对象，不是裸 socket
};