使用QTcpServer和QTcpSocket在QT中实现TCP通信的方法

这篇具有很好参考价值的文章主要介绍了使用QTcpServer和QTcpSocket在QT中实现TCP通信的方法。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

1. TCP通信概述

TCP是一种被大多数Internet网络协议(如HTTP)用于数据传输的低级网络协议,它是可靠的、面向流、面向连接的传输协议,特别适合于连续数据传输。

TCP通信必须先建立TCP连接,分为服务器端和客户端。
Qt提供QTcpServer类和QTcpSocket类用于建立TCP通信。
服务器端必须使用QTcpServer用于端口监听,建立服务器;QTcpSocket用于建立连接后使用套接字进行通信。

2. QTcpServer

QTcpServer继承于QObject

2.1 公共函数

void close() 关闭服务器,停止网络监听

bool listen(address, port) 在给定IP地址和端口上开始监听,若成功返回true。address = QHostAddress addr(IP)

bool isListening() 返回true表示服务器处于监听状态

QTcpSocket* nextPendingConnection() 返回下一个等待接入的连接。套接字是作为服务器的子节点创建的,这意味着当QTcpServer对象被销毁时,它将被自动删除。在使用完对象后显式地删除它,以避免浪费内存。如果在没有挂起连接时调用此函数,则返回0。注意:返回的QTcpSocket对象不能从其他线程使用。如果您想使用来自另一个线程的传入连接,则需要重写incomingConnection()。

QHostAddress serverAddress() 若服务器处于监听状态,返回服务器地址

quint16 serverPort() 若服务器处于监听状态,返回服务器监听端口

bool waitForNewConnection() 以阻塞的方式等待新的连接

2.2 信号

void acceptError(QAbstractSocket::SocketError socketError) 当接受一个新的连接发生错误时发射此信号,参数socketError描述了错误信息

void newConnection() 当有新的连接时发射此信号

2.3 保护函数

void incomingConnection(qintptr socketDescriptor) 当有新的连接可用时,QTcpServer内部调用此函数,创建一个QTcpServer对象,添加到内部可用新连接列表,然后发射newConnection()信号。用户若从QTcpServer继承定义类,可以重定义此函数,但必须调用addPendingConnection()。qintptr根据系统类型不同而不同,32位为qint32,64位为qint64。

void addPendingConnection(QTcpSocket* socket) 由incomingConnection()调用,将创建的QTcpSocket添加到内部新可用连接列表。

3. QTcpSocket

QTcpSocket是从QIODevice间接继承的

QIODevice -> QAbstractSocket -> QTcpSocket

QTcpSocket类除了构造和析构,其他函数都是从QAbstractSocket继承或重定义的

3.1 公共函数

void connectToHost(QHostAddress& address, quint16 port) 以异步方式连接到指定IP地址和端口的TCP服务器,连接成功会发送connected()信号

void disconnectFromHost() 断开socket,关闭成功后会发射disconnected()信号

bool waitForConnected() 等待直到建立socket连接

bool waitForDisconnected() 等待直到断开socket连接

QHostAddress localAddress() 返回本socket的地址

quint16 localPort 返回本socket的端口

QHostAddress peerAddress() 在已连接状态下,返回对方socket的地址

QString peerName() 返回connectToHost()连接到的对方的主机名

quint16 peerPort() 在已连接状态下,返回对方socket的端口

qint64 readBufferSize() 返回内部读取缓冲区的大小,该大小决定了read()和realAll()函数能读出的数据的大小

void setReadBufferSize(qint64 size) 设置内部读取缓冲区的大小

qint64 bytesAvailable() 返回需要读取的缓冲区的数据的字节数

bool canReadLine() 如果有行数据要从socket缓冲区读取,则返回true

SocketState state() 返回socket当前的状态

3.2 信号

void connected() connectToHost()成功连接到服务器后会发射此信号

void disconnected() 断开socket连接后会发射此信号

void error(QAbstractSocket::SocketError socketError) 当socket发生错误时会发射此信号

void hostFound() 调用connectToHost()找到主机后会发射此信号

void stateChanged(QAbstractSocket::SocketState socketState) 当socket状态发生变化时会发射此信号,参数socketState表示socket当前的状态

void readyRead() 当缓冲区有新数据需要读取时会发射此信号,在此信号的槽函数里读取缓冲区的数据

4. 代码示例

4.1 服务器端

使用Qt网络模块,需要在配置文件.pro中添加:

Qt += network

MainWindow.h

#ifndef MAINWINDOW_H#define MAINWINDOW_H#include <QAction>#include <QCloseEvent>#include <QComboBox>#include <QGridLayout>#include <QHostInfo>#include <QLabel>#include <QLineEdit>#include <QMainWindow>#include <QMessageBox>#include <QPlainTextEdit>#include <QPushButton>#include <QSpinBox>#include <QTcpServer>#include <QTcpSocket>namespace Ui {
    class MainWindow;}class MainWindow : public QMainWindow {
    Q_OBJECTpublic:
    explicit MainWindow(QWidget* parent = 0);
    ~MainWindow();protected:
    void closeEvent(QCloseEvent* event);private slots:
    //工具栏按钮
    void slotActStartTriggered();
    void slotActStopTriggered();
    void slotActClearTriggered();
    void slotActQuitTriggered();

    //界面按钮
    void slotBtnSendClicked();

    //自定义槽函数
    void slotNewConnection();       // QTcpServer的newConnection()信号
    void slotClientConnected();     //客户端socket连接
    void slotClientDisconnected();  //客户端socket断开连接
    void slotSocketStateChange(QAbstractSocket::SocketState socketState);
    void slotSocketReadyRead();  //读取socket传入的数据private:
    Ui::MainWindow* ui;

    QAction* m_pActStartListen;
    QAction* m_pActStopListen;
    QAction* m_pActClearText;
    QAction* m_pActQuit;
    QWidget* m_pCentralWidget;
    QGridLayout* m_pGridLayout;
    QLabel* m_pLabel1;
    QComboBox* m_pComBoxIP;
    QLabel* m_pLabel2;
    QSpinBox* m_pSpinBoxPort;
    QLineEdit* m_pLineEdit;
    QPushButton* m_pBtnSend;
    QPlainTextEdit* m_pPlainText;
    QLabel* m_pLabListenStatus;  //状态栏标签
    QLabel* m_pLabSocketState;   //状态栏标签
    QTcpServer* m_pTcpServer;    // TCP服务器
    QTcpSocket* m_pTcpSocket;    // TCP通信的socket

    QString getLocalIP();  //获取本机IP地址};#endif  // MAINWINDOW_H

MainWindow.cpp

#include "mainwindow.h"#include "ui_mainwindow.h"MainWindow::MainWindow(QWidget* parent) : QMainWindow(parent), ui(new Ui::MainWindow) {
    ui->setupUi(this);
    this->setWindowTitle(QStringLiteral("TCP服务端"));
    ui->menuBar->hide();

    //工具栏
    ui->mainToolBar->setToolButtonStyle(Qt::ToolButtonTextUnderIcon);  //设置工具栏显示风格(图标在上文字在下)
    m_pActStartListen = new QAction(QIcon(":/new/prefix1/res/开始.png"), QStringLiteral("开始监听"), this);
    m_pActStopListen = new QAction(QIcon(":/new/prefix1/res/暂停.png"), QStringLiteral("停止监听"), this);
    m_pActClearText = new QAction(QIcon(":/new/prefix1/res/清空数据.png"), QStringLiteral("清空文本框"), this);
    m_pActQuit = new QAction(QIcon(":/new/prefix1/res/退出.png"), QStringLiteral("退出"), this);
    ui->mainToolBar->addAction(m_pActStartListen);
    ui->mainToolBar->addAction(m_pActStopListen);
    ui->mainToolBar->addAction(m_pActClearText);
    ui->mainToolBar->addSeparator();
    ui->mainToolBar->addAction(m_pActQuit);

    //界面布局
    m_pCentralWidget = new QWidget(this);
    m_pGridLayout = new QGridLayout(m_pCentralWidget);
    m_pLabel1 = new QLabel(QStringLiteral("监听地址"), m_pCentralWidget);  //父对象为新的widget
    // label对象被析构了,所以不会在界面显示。label1需要作为成员变量才可显示或者用指针
    //    QLabel label1;
    //    label1.setText("监听地址");
    m_pComBoxIP = new QComboBox(m_pCentralWidget);
    // m_pComBoxIP->addItem("192.168.1.104");  // QComboBox设置默认项必须添加项
    //必须先add项才能操作下面
    //    comBoxAddr->setCurrentIndex(0);
    //    comBoxAddr->setCurrentText("192.168.1.104");
    m_pLabel2 = new QLabel(QStringLiteral("监听端口"), m_pCentralWidget);
    m_pSpinBoxPort = new QSpinBox(m_pCentralWidget);
    m_pSpinBoxPort->setMinimum(1);
    m_pSpinBoxPort->setMaximum(65535);  //端口范围1~65535
    m_pLineEdit = new QLineEdit(m_pCentralWidget);
    m_pBtnSend = new QPushButton(QStringLiteral("发送消息"), m_pCentralWidget);
    m_pPlainText = new QPlainTextEdit(m_pCentralWidget);
    m_pGridLayout->addWidget(m_pLabel1, 0, 0, Qt::AlignRight);
    // GLayout->addWidget(&label1, 0, 0, Qt::AlignRight);  //对象可以用&的方式
    m_pGridLayout->addWidget(m_pComBoxIP, 0, 1, 1, 2);
    m_pGridLayout->addWidget(m_pLabel2, 0, 3, Qt::AlignRight);
    m_pGridLayout->addWidget(m_pSpinBoxPort, 0, 4);
    m_pGridLayout->addWidget(m_pLineEdit, 1, 0, 1, 4);
    m_pGridLayout->addWidget(m_pBtnSend, 1, 4);
    m_pGridLayout->addWidget(m_pPlainText, 2, 0, 5, 5);
    this->setCentralWidget(m_pCentralWidget);

    //状态栏
    m_pLabListenStatus = new QLabel(QStringLiteral("监听状态:"));
    m_pLabListenStatus->setMinimumWidth(150);
    ui->statusBar->addWidget(m_pLabListenStatus);
    m_pLabSocketState = new QLabel(QStringLiteral("Socket状态:"));
    m_pLabSocketState->setMinimumWidth(200);
    ui->statusBar->addWidget(m_pLabSocketState);

    QString localIP = getLocalIP();
    this->setWindowTitle(this->windowTitle() + "---本机IP:" + localIP);
    m_pComBoxIP->addItem(localIP);

    m_pTcpServer = new QTcpServer(this);
    connect(m_pTcpServer, &QTcpServer::newConnection, this, &MainWindow::slotNewConnection);

    connect(m_pActStartListen, &QAction::triggered, this, &MainWindow::slotActStartTriggered);
    connect(m_pActStopListen, &QAction::triggered, this, &MainWindow::slotActStopTriggered);
    connect(m_pBtnSend, &QPushButton::clicked, this, &MainWindow::slotBtnSendClicked);
    connect(m_pActClearText, &QAction::triggered, this, &MainWindow::slotActClearTriggered);
    connect(m_pActQuit, &QAction::triggered, this, &MainWindow::slotActQuitTriggered);}MainWindow::~MainWindow() { delete ui; }void MainWindow::closeEvent(QCloseEvent* event) {
	//关闭窗口时停止监听
    if (m_pTcpServer->isListening())
        m_pTcpServer->close();  //停止网络监听
    QMessageBox::StandardButton button = QMessageBox::question(this, QStringLiteral(""), "是否退出?");
    if (button == QMessageBox::StandardButton::Yes) {
        event->accept();
    } else {
        event->ignore();
    }}void MainWindow::slotActStartTriggered() {
    //开始监听
    QString IP = m_pComBoxIP->currentText();
    quint16 port = m_pSpinBoxPort->value();
    QHostAddress addr(IP);
    m_pTcpServer->listen(addr, port);  //开始监听
    // m_pTcpServer->listen(QHostAddress::LocalHost, port);  //监听本机上某个端口
    // QHostAddress::LocalHost :IPv4本地主机地址。等价于QHostAddress("127.0.0.1")
    m_pPlainText->appendPlainText("**开始监听...");
    m_pPlainText->appendPlainText("**服务器地址:" + m_pTcpServer->serverAddress().toString());
    m_pPlainText->appendPlainText("**服务器端口:" + QString::number(m_pTcpServer->serverPort()));
    m_pActStartListen->setEnabled(false);  //开始之后不能再开始
    m_pActStopListen->setEnabled(true);
    m_pLabListenStatus->setText(QStringLiteral("监听状态:正在监听"));}void MainWindow::slotActStopTriggered() {
    //停止监听
    if (m_pTcpServer->isListening()) {
        m_pTcpServer->close();
        m_pActStartListen->setEnabled(true);
        m_pActStopListen->setEnabled(false);
        m_pLabListenStatus->setText("监听状态:已停止监听");
    }}void MainWindow::slotActClearTriggered() { m_pPlainText->clear(); }void MainWindow::slotActQuitTriggered() { this->close(); }void MainWindow::slotBtnSendClicked() {
    //发送一行字符串,以换行符结束
    QString msg = m_pLineEdit->text();
    m_pPlainText->appendPlainText("[out]: " + msg);
    m_pLineEdit->clear();
    m_pLineEdit->setFocus();  // 发送完设置焦点

    //字符串的传递一般都要转换为UTF-8格式,编译器不同可能导致乱码,UFTF-8格式是统一的格式,每个编译器都会带,防止乱码
    QByteArray str = msg.toUtf8();  //返回字符串的UTF-8格式
    str.append('\n');
    m_pTcpSocket->write(str);}void MainWindow::slotNewConnection() {
    m_pTcpSocket = m_pTcpServer->nextPendingConnection();  //获取socket
    connect(m_pTcpSocket, &QTcpSocket::connected, this, &MainWindow::slotClientConnected);
    // slotClientConnected();
    connect(m_pTcpSocket, &QTcpSocket::disconnected, this, &MainWindow::slotClientDisconnected);
    connect(m_pTcpSocket, &QTcpSocket::stateChanged, this, &MainWindow::slotSocketStateChange);
    slotSocketStateChange(m_pTcpSocket->state());
    connect(m_pTcpSocket, &QTcpSocket::readyRead, this, &MainWindow::slotSocketReadyRead);}void MainWindow::slotClientConnected() {
    //客户端接入时
    m_pPlainText->appendPlainText("**client socket connected");
    m_pPlainText->appendPlainText("**peer address: " + m_pTcpSocket->peerAddress().toString());  //对端的地址
    m_pPlainText->appendPlainText("**peer port: " + QString::number(m_pTcpSocket->peerPort()));  //对端的端口}void MainWindow::slotClientDisconnected() {
    //客户端断开连接时
    m_pPlainText->appendPlainText("**client socket disconnected");
    m_pTcpSocket->deleteLater();}void MainWindow::slotSocketStateChange(QAbstractSocket::SocketState socketState) {
    // socket状态变化时
    switch (socketState) {
        case QAbstractSocket::UnconnectedState: m_pLabSocketState->setText("socket状态:UnconnectedSate"); break;
        case QAbstractSocket::HostLookupState: m_pLabSocketState->setText("socket状态:HostLookupState"); break;
        case QAbstractSocket::ConnectingState: m_pLabSocketState->setText("socket状态:ConnectingState"); break;
        case QAbstractSocket::ConnectedState: m_pLabSocketState->setText("socket状态:ConnectedState"); break;
        case QAbstractSocket::BoundState: m_pLabSocketState->setText("socket状态:BoundState"); break;
        case QAbstractSocket::ClosingState: m_pLabSocketState->setText("socket状态:ClosingState"); break;
        case QAbstractSocket::ListeningState: m_pLabSocketState->setText("socket状态:ListeningState"); break;
    }}void MainWindow::slotSocketReadyRead() {
    //读取缓冲区行文本
    while (m_pTcpSocket->canReadLine()) {
        m_pPlainText->appendPlainText("[in]: " + m_pTcpSocket->readLine());
    }}QString MainWindow::getLocalIP() {
    //获取本机IPv4地址
    QString hostName = QHostInfo::localHostName();  //本地主机名
    QHostInfo hostInfo = QHostInfo::fromName(hostName);
    QString localIP = "";
    QList<QHostAddress> addList = hostInfo.addresses();
    if (!addList.isEmpty()) {
        for (int i = 0; i < addList.count(); i++) {
            QHostAddress aHost = addList.at(i);
            if (QAbstractSocket::IPv4Protocol == aHost.protocol()) {
                localIP = aHost.toString();
                break;
            }
        }
    }
    return localIP;}

4.2 客户端

使用Qt网络模块,需要在配置文件.pro中添加:

Qt += network

MainWindow.h

#ifndef MAINWINDOW_H#define MAINWINDOW_H#include <QAction>#include <QGridLayout>#include <QHBoxLayout>#include <QHostInfo>#include <QLabel>#include <QLineEdit>#include <QMainWindow>#include <QMessageBox>#include <QPlainTextEdit>#include <QPushButton>#include <QSpinBox>#include <QTcpSocket>namespace Ui {
    class MainWindow;}class MainWindow : public QMainWindow {
    Q_OBJECTpublic:
    explicit MainWindow(QWidget* parent = 0);
    ~MainWindow();protected:
    void closeEvent(QCloseEvent* event);private slots:
    //工具栏按钮
    void slotActConnectTriggered();
    void slotActDisConnectTriggered();
    void slotActClearTriggered();
    void slotActQuitTriggered();

    //界面按钮
    void slotBtnSendClicked();

    //自定义槽函数
    void slotConnected();
    void slotDisconnected();
    void slotSocketStateChange(QAbstractSocket::SocketState socketState);
    void slotSocketReadyRead();private:
    Ui::MainWindow* ui;

    QAction* m_pActConnectServer;
    QAction* m_pActDisconnect;
    QAction* m_pActClear;
    QAction* m_pActQuit;
    QWidget* m_pCentralWidget;
    QLabel* m_pLabel1;
    QLabel* m_pLabel2;
    QLineEdit* m_pLineEditIP;
    QSpinBox* m_pSpinBoxPort;
    QLineEdit* m_pLineEdit;
    QPushButton* m_pBtnSend;
    QPlainTextEdit* m_pPlainText;
    QLabel* m_pLabSocketState;
    QTcpSocket* m_pTcpClient;

    QString getLocalIP();
    void loadStyleFile();};#endif  // MAINWINDOW_H

MainWindow.cpp

#include "mainwindow.h"#include "ui_mainwindow.h"MainWindow::MainWindow(QWidget* parent) : QMainWindow(parent), ui(new Ui::MainWindow) {
    ui->setupUi(this);
    this->setWindowTitle(QStringLiteral("TCP客户端"));
    ui->menuBar->hide();

    // QSS样式
    loadStyleFile();

    //工具栏
    ui->mainToolBar->setToolButtonStyle(Qt::ToolButtonTextBesideIcon);
    ui->mainToolBar->setMinimumHeight(50);
    m_pActConnectServer = new QAction(QIcon(":/new/prefix1/res/链接.png"), QStringLiteral("连接服务器"), this);
    m_pActDisconnect = new QAction(QIcon(":/new/prefix1/res/断开链接.png"), QStringLiteral("断开连接"), this);
    m_pActClear = new QAction(QIcon(":/new/prefix1/res/清空数据.png"), QStringLiteral("清空文本框"), this);
    m_pActQuit = new QAction(QIcon(":/new/prefix1/res/退出.png"), QStringLiteral("退出"), this);
    ui->mainToolBar->addAction(m_pActConnectServer);
    ui->mainToolBar->addAction(m_pActDisconnect);
    ui->mainToolBar->addAction(m_pActClear);
    ui->mainToolBar->addSeparator();
    ui->mainToolBar->addAction(m_pActQuit);

    //布局
    m_pCentralWidget = new QWidget(this);
    m_pLabel1 = new QLabel(QStringLiteral("服务器地址"), m_pCentralWidget);
    m_pLabel2 = new QLabel(QStringLiteral("端口"), m_pCentralWidget);
    m_pLineEditIP = new QLineEdit(m_pCentralWidget);
    m_pSpinBoxPort = new QSpinBox(m_pCentralWidget);
    m_pSpinBoxPort->setMinimum(1);
    m_pSpinBoxPort->setMaximum(65535);
    QHBoxLayout* HLay1 = new QHBoxLayout();
    HLay1->addWidget(m_pLabel1, 2);
    HLay1->addWidget(m_pLineEditIP, 6);
    HLay1->addWidget(m_pLabel2, 2, Qt::AlignRight);
    HLay1->addWidget(m_pSpinBoxPort, 3);
    m_pLineEdit = new QLineEdit(m_pCentralWidget);
    m_pBtnSend = new QPushButton(QStringLiteral("发送消息"), m_pCentralWidget);
    QHBoxLayout* HLay2 = new QHBoxLayout();
    HLay2->addWidget(m_pLineEdit, 10);
    HLay2->addWidget(m_pBtnSend, 2);
    m_pPlainText = new QPlainTextEdit(m_pCentralWidget);
    QGridLayout* GridLayout = new QGridLayout(m_pCentralWidget);
    GridLayout->addLayout(HLay1, 0, 0);
    GridLayout->addLayout(HLay2, 1, 0);
    GridLayout->addWidget(m_pPlainText);
    this->setCentralWidget(m_pCentralWidget);

    //状态栏
    m_pLabSocketState = new QLabel(this);
    m_pLabSocketState->setText(QStringLiteral("socket状态:"));
    ui->statusBar->addWidget(m_pLabSocketState);
    m_pLabSocketState->setMinimumWidth(150);

    QString localIP = getLocalIP();
    this->setWindowTitle(this->windowTitle() + "---本机IP:" + localIP);
    m_pLineEditIP->setText(localIP);

    m_pTcpClient = new QTcpSocket(this);
    connect(m_pActConnectServer, &QAction::triggered, this, &MainWindow::slotActConnectTriggered);
    connect(m_pActDisconnect, &QAction::triggered, this, &MainWindow::slotActDisConnectTriggered);
    connect(m_pActClear, &QAction::triggered, this, &MainWindow::slotActClearTriggered);
    connect(m_pActQuit, &QAction::triggered, this, &MainWindow::slotActQuitTriggered);
    connect(m_pBtnSend, &QPushButton::clicked, this, &MainWindow::slotBtnSendClicked);
    connect(m_pTcpClient, &QTcpSocket::connected, this, &MainWindow::slotConnected);
    connect(m_pTcpClient, &QTcpSocket::disconnected, this, &MainWindow::slotDisconnected);
    connect(m_pTcpClient, &QTcpSocket::stateChanged, this, &MainWindow::slotSocketStateChange);
    connect(m_pTcpClient, &QTcpSocket::readyRead, this, &MainWindow::slotSocketReadyRead);}MainWindow::~MainWindow() { delete ui; }void MainWindow::closeEvent(QCloseEvent* event) {
	//关闭之前断开连接
    if (m_pTcpClient->state() == QAbstractSocket::ConnectedState)
        m_pTcpClient->disconnectFromHost();
    QMessageBox::StandardButton button = QMessageBox::question(this, QStringLiteral(""), "是否退出?");
    if (button == QMessageBox::StandardButton::Yes) {
        event->accept();
    } else {
        event->ignore();
    }}void MainWindow::slotActConnectTriggered() {
    //连接到服务器按钮
    QString addr = m_pLineEditIP->text();
    quint16 port = m_pSpinBoxPort->value();
    m_pTcpClient->connectToHost(addr, port);}void MainWindow::slotActDisConnectTriggered() {
    //断开连接按钮
    if (m_pTcpClient->state() == QAbstractSocket::ConnectedState) {
        m_pTcpClient->disconnectFromHost();
    }}void MainWindow::slotActClearTriggered() { m_pPlainText->clear(); }void MainWindow::slotActQuitTriggered() { this->close(); }void MainWindow::slotBtnSendClicked() {
    //发送数据
    QString msg = m_pLineEdit->text();
    m_pPlainText->appendPlainText("[out]: " + msg);
    m_pLineEdit->clear();
    m_pLineEdit->setFocus();
    QByteArray str = msg.toUtf8();
    str.append('\n');
    m_pTcpClient->write(str);}void MainWindow::slotConnected() {
    // Connected()信号槽函数
    m_pPlainText->appendPlainText("**已连接到服务器");
    m_pPlainText->appendPlainText("**peer address: " + m_pTcpClient->peerAddress().toString());
    m_pPlainText->appendPlainText("**peer port: " + QString::number(m_pTcpClient->peerPort()));
    m_pActConnectServer->setEnabled(false);
    m_pActDisconnect->setEnabled(true);}void MainWindow::slotDisconnected() {
    // Disconnected()信号槽函数
    m_pPlainText->appendPlainText("**已断开与服务器的连接");
    m_pActConnectServer->setEnabled(true);
    m_pActDisconnect->setEnabled(false);}void MainWindow::slotSocketStateChange(QAbstractSocket::SocketState socketState) {
    switch (socketState) {
        case QAbstractSocket::UnconnectedState: m_pLabSocketState->setText("socket状态:UnconnectedSate"); break;
        case QAbstractSocket::HostLookupState: m_pLabSocketState->setText("socket状态:HostLookupState"); break;
        case QAbstractSocket::ConnectingState: m_pLabSocketState->setText("socket状态:ConnectingState"); break;
        case QAbstractSocket::ConnectedState: m_pLabSocketState->setText("socket状态:ConnectedState"); break;
        case QAbstractSocket::BoundState: m_pLabSocketState->setText("socket状态:BoundState"); break;
        case QAbstractSocket::ClosingState: m_pLabSocketState->setText("socket状态:ClosingState"); break;
        case QAbstractSocket::ListeningState: m_pLabSocketState->setText("socket状态:ListeningState"); break;
    }}void MainWindow::slotSocketReadyRead() {
    while (m_pTcpClient->canReadLine()) {
        m_pPlainText->appendPlainText("[in]: " + m_pTcpClient->readLine());
    }}QString MainWindow::getLocalIP() {
    QString hostName = QHostInfo::localHostName();
    QHostInfo hostInfo = QHostInfo::fromName(hostName);
    QString localIP = "";
    QList<QHostAddress> addrList = hostInfo.addresses();
    if (!addrList.isEmpty()) {
        for (int i = 0; i < addrList.size(); i++) {
            QHostAddress aHost = addrList.at(i);
            if (aHost.protocol() == QAbstractSocket::IPv4Protocol) {
                localIP = aHost.toString();
                break;
            }
        }
    }
    return localIP;}/* 添加QSS样式 */void MainWindow::loadStyleFile() {
    QFile file(":/new/prefix1/sytle/style.css");
    file.open(QFile::ReadOnly);
    QString styleSheet = tr(file.readAll());
    this->setStyleSheet(styleSheet);
    file.close();}

4.3 界面显示

QTcpServer,QTcpSocket,TCP通信,QT编程
客户端界面使用了QSS文章来源地址https://www.toymoban.com/news/detail-426600.html

到了这里,关于使用QTcpServer和QTcpSocket在QT中实现TCP通信的方法的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • C++ Qt开发:QTcpSocket网络通信组件

    Qt 是一个跨平台C++图形界面开发库,利用Qt可以快速开发跨平台窗体应用程序,在Qt中我们可以通过拖拽的方式将不同组件放到指定的位置,实现图形化开发极大的方便了开发效率,本章将重点介绍如何运用 QTcpSocket 组件实现基于TCP的网络通信功能。 QTcpSocket 和 QTcpServer 是Qt中

    2024年03月18日
    浏览(48)
  • 【Qt网络编程】实现TCP协议通信

    传输控制协议(TCP,Transmission Control Protocol)是 一种面向连接的、可靠的、基于字节流的传输层通信协议 ,由IETF的RFC 793 定义。 TCP建立连接前,需要进行三次握手,如下图所示: TCP断开连接前,需要进行四次挥手,如下图所示: Qt中提供了QTcpSocket类和QTcpServer类分别用于创

    2024年02月16日
    浏览(48)
  • 网络通信/QTcpSocket/实现一个可在子线程中发送和接收数据的TCP客户端

    近来一直接使用WinSocket做网络编程,有很长一段时间不再使用Qt框架下的相关网路通信类。有不少之前积压的问题直到现在也没怎么弄清楚,在CSDN中乱七八糟的存了好几篇草稿,亟待整理。最近要写一个简单地相机升级程序,于是重操旧业。 网络通信中,尤其是在收发工作较

    2024年02月08日
    浏览(55)
  • Qt 套接字类(QTcpSocket和QUdpSocket)解密:迈向 Qt 网络编程之巅

    套接字类在网络编程中起着至关重要的作用。套接字(Socket)为基于网络的通信提供了一种机制,使得不同设备、不同操作系统上的应用程序可以互相传输数据。套接字类负责建立连接、发送和接收数据、处理错误等任务,以简化网络通信的实现。通过使用套接字类,开发人

    2023年04月19日
    浏览(32)
  • 【window环境、Linux环境、QT三种方法实现TCP通信】

    提示:文章写完后,目录可以自动生成,如何生成可参考右边的帮助文档 大多数项目都在Linux系列的操作系统下开发服务器端,而多数客户端是在Windows平台下开发的。不仅如此,有时应用程序还需要在两个平台之间相互切换。因此,学习套接字编程的过程中,有必要兼顾Wi

    2024年04月25日
    浏览(34)
  • 如何在STM32中实现TCP通信?

    如何在STM32中实现TCP通信? TCP通信在计算机网络中扮演着重要角色,实现它需要兼顾硬件和软件因素。 硬件层面,某些STM32处理器内置了Ethernet MAC,这有利于简化网络通信的部署。若处理器缺乏内置MAC,需外接以太网控制器来实现连接。 软件方面,TCP通信必须倚赖TCP/IP网络协

    2024年02月02日
    浏览(42)
  • QTcpServer简单的TCP服务器连接

    简单实现控制TCP服务器获取连接的套接字。点击断开服务器即可关闭所有连接,最大连接数量为5个。 声明源文件 声明的头文件

    2024年02月08日
    浏览(45)
  • Linux网络编程:socket、客户端服务器端使用socket通信(TCP)

    socket(套接字),用于网络中不同主机间进程的通信。 socket是一个伪文件,包含读缓冲区、写缓冲区。 socket必须成对出现。 socket可以建立主机进程间的通信,但需要协议(IPV4、IPV6等)、port端口、IP地址。          (1)创建流式socket套接字。                 a)此s

    2024年02月11日
    浏览(65)
  • QT网络通信-TCP、UDP通信

    时间记录:2024/1/17 pro文件添加模块network (1)创建TCP服务器对象 QTcpServer (2)为 QTcpServer 对象的 newConnection 信号绑定槽,用来监听TCP客户端的新连接,有新的客户端连接便会触发此信号 (3)使用 nextPendingConnection 方法获取连接的Tcp客户端对象 QTcpSocket (4)为 QTcpSocket 的 r

    2024年01月18日
    浏览(58)
  • Java【网络编程2】使用 TCP 的 Socket API 实现客户端服务器通信(保姆级教学, 附代码)

    📕各位读者好, 我是小陈, 这是我的个人主页 📗小陈还在持续努力学习编程, 努力通过博客输出所学知识 📘如果本篇对你有帮助, 烦请点赞关注支持一波, 感激不尽 📙 希望我的专栏能够帮助到你: JavaSE基础: 基础语法, 类和对象, 封装继承多态, 接口, 综合小练习图书管理系统

    2024年02月05日
    浏览(65)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包