TCP通信之QTcpServer和QTcpSocket，服务器和客户端通讯

最新推荐文章于 2024-05-13 02:38:12 发布
最新推荐文章于 2024-05-13 02:38:12 发布
阅读量5.7k 收藏 40
点赞数 9
分类专栏： 专栏 - QtExamples系列 学习 - Qt 文章标签： QTcpServer QTcpSocket 网络协议
本文所有内容，包括文字、图片、音频、视频等，均受到法律保护。未经作者许可，任何单位或个人不得擅自转载、摘编、复制或以其他方式使用本文内容。如需转载，请与作者联系，并在取得授权后注明“转载自[作者名]的[文章标题]，原文链接：[原文链接]”。违反上述声明者，作者将保留追究法律责任的权利。谢谢合作！
本文链接：https://blog.csdn.net/qq_33154343/article/details/103759735
版权

简 述： 了解TCP通信之QTcpServer和QTcpSocket，服务器和客户端通讯，书写一个简单地例子；然后写了一个小的 Qt例子，用来实现和验证它的空间的一些属性和功能的用法。

文章目录


相关博文：

有着一些关联的博文其他参考：


系统环境：

编程环境： MacOS 10.14.6 (18G103) 编程软件： Qt 5.9.8， Qt Creator 4.8.2


Tcp通信概述：

我想能够看到网络这一部分的人，基本都是有着基本的网络认知；这里为了这一个系列的完整性，还是决定将本系列的基本知识仍旧写出来。万一之前的你是没有怎么接触过这类篇文章的鸭鸭呢？就算是完全不知，但是一些基础的还是能够让你能够有所了解，再具体的就进行自行goole和专业📚进行扩展深入扩展学习，博文尽量都提一笔，其余更多待你自行发掘。

TCP特点：

可靠，面向流传播，面向协议的一种传输协议；特别适合用于连续数据传输。实际🌰：QQ的在线发送文件，就是为了确保文件发送的完整性，使用的TCP协议。


QTcpServer属性：

TCP通信，必须先进行TCP连接，通信端口分为服务器端口和客户端。

QTcpServer是从QObject继承的类，主要是用于服务器建立网络监听，创立Socket连接的；其中主要的一些常用接口，提供·如下：

类型函数功能
公共函数void close()关闭服务器，停止网络监听
bool listen()在给定IP地址和端口上开始监听，若是成功，就返回true
bool isListening()返回true表示服务器处于监听状态
QTcpSocket * nextPendingConnection()返回下一个等待接入的连接
QHostAddres serverAddress()如果服务器处于监听状态，返回服务器地址
quint16 serverPort()如果服务器处于监听状态，返回服务器端口
bool waitForNewConnection()以阻塞方式等待新的连接
信号void acceptError( QAbstractSocket::SocketError socketError )当接受一个新的连接时大声了错误，就发射此信号；参数socketError描述错误信息
void new Connection()当有新的信号连接时候，发射此信号
保护函数void incomingConnection(qintptr socketDescriptor)当有一个新的连接可用时，QTcpServer内部调用此函数，创建一个QTcpSocket对象，添加到内部可用新连接列表，然后发射newConnetion()信号，用户若是从QTcpServer继承定义类，可以重定义此函数，但是必须调用QtcpSocket继承定义类，可以重新定义此函数，但是必须调用addPendingConnetion()
void addPendingConnection(QTcp Socket *socket)由incomingtion()调用，将创建的QTcpSocket添加到内部新可用连接列表

服务器的程序首先是需要调用QTcpServer进行监听的【这个时候，是指定监听的IP和port的】，然后当QScoket连接的时候，会发射信号📶，newConnection()，在newConnection()的对应好的槽函数中，可以用nextPendingConnetion()接收客户端的连接，然后使用QSocket与客户端进行通信。

QTcp/QUdp继承关系图：


QAbstractSocket接口讲解：

其中主要的QAbstractSocket的主要的接口函数如下：

类型函数功能
公共函数void connectToHost(QHostAddress headdress, quint16 port,)以异步的方式连接到指定的IP地址和端口的TCP服务器，连接成功会发射connected()信号
void disconnectFromHost()断开sokcet，关闭成功后发射disconnection()信号
bool waitForConnected()等待直到建立socket连接
bool waitForDisconnected()等待直到断开socket连接
QHostAddress localAddress()返回本socket的地址
quint16 localPort()返回本socket的端口
QHostAddress peerAddress()在已经连接状态下，返回对方socket的地址
QString peerName()返回connetToHost()连接到对方的主机的名
quint16 peerPort()在已连接的状态下，返回对方的socket的port
qint64 readBuffer Size()返回内部读取缓冲区的大小的数据的字节数；该大小决定了read()和readAll()函数能够读取出来的数据的大小
void setReadBuAerSize(qint64 size)数据内部读取缓冲区的数据的字节数
qint64 bytesAvailable()返回需要读取的缓冲区的字节数字
bool canReadLine()如果有行数据要从socket缓冲区读取，就返回true
SocketState state()返回当前socket状态
信号📶void connected()connectionToHost()成功连接到服务器后发射此信号
void disconnected()当socket断开连接时，发射此信号
void error(QAbstractSocket::SocketError socketError)当socket发生错误时，发射此信号
void hostFound()调用connectToHost()找到主机后发射此信号
void stateChanged(QAbstractSocket::SocketState socketState)当socket的状态变化时候发射此信号，参数socketState表示了socket当前的状态
void ready Read()当缓冲区的数据需要读取时候，发射此信号，在此信号的槽函数里面读取缓冲区的数据

运行效果：

这里先放一张运行效果图：


源码分析：

这里将TCP通信的服务器和客户端拆分为两个小的项目来写，其结构如下：

其中核心部分的源码，重点和一些难点以及需要注意的一些地方，贴出来如下：

其中服务器端：

/*
 * Copyright (C)  2019 ~ 2019 touwoyimuli.  All rights reserved.
 *
 * Author:  touwoyimuli <touwoyimuli@gmai.com>
 *
 * github:  https://github.com/touwoyimuli
 * blogs:   https://touwoyimuli.github.io/
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <https://touwoyimuli.github.io/>.
 */
#ifndef EXTCPSERVER_H
#define EXTCPSERVER_H

#include <QMainWindow>
#include <QLabel>
#include <QTcpServer>
#include <QTcpSocket>
#include <QHostInfo>

namespace Ui {
class ExTcpServer;
}

class ExTcpServer : public QMainWindow
{
    Q_OBJECT

public:
    explicit ExTcpServer(QWidget *parent = nullptr);
    ~ExTcpServer();

private:
    QString getLocalIp();      //获取本机 IP

protected:
    void closeEvent(QCloseEvent* event);

private slots:
//UI的槽函数
    void on_actStart_triggered();      //开始监听
    void on_actStop_triggered();       //停止监听
    void on_actClear_triggered();      //清除文本框内容
    void on_actQuit_triggered();       //退出程序
    void on_btnSend_clicked();         //发送消息

//自定义的槽函数
    void onSocketReadyRead();          //读取 socket 传入时候的数据
    void onClientConnected();          //client socket conneted
    void onClientDisonnected();        //client socket disconneted
    void onNewConnection();            //QTcpServer 的 newConnect() 信号
    void onSocketStateChange(QAbstractSocket::SocketState socketState);

private:
    Ui::ExTcpServer *ui;

    QLabel* m_labListen;
    QLabel* m_labSocket;
    QTcpServer* m_tcpServer;
    QTcpSocket* m_tcpSocket;


};

#endif // EXTCPSERVER_H


#include "ExTcpServer.h"
#include "ui_ExTcpServer.h"

ExTcpServer::ExTcpServer(QWidget *parent) :
    QMainWindow(parent),
    ui(new Ui::ExTcpServer)
{
    ui->setupUi(this);

    m_labListen = new QLabel("监听状态：");
    m_labSocket = new QLabel("socket状态：");
    m_labListen->setMidLineWidth(200);
    m_labSocket->setMinimumWidth(200);
    ui->statusBar->addWidget(m_labListen);
    ui->statusBar->addWidget(m_labSocket);

    QString localeIp = getLocalIp();
    setWindowTitle(windowTitle() + "---IP地址：" + localeIp);
    ui->comboBox->addItem(localeIp);

    m_tcpServer = new QTcpServer(this);
    connect(m_tcpServer, SIGNAL(newConnection()), this, SLOT(onNewConnection()));
}

ExTcpServer::~ExTcpServer()
{
    delete ui;
}

QString ExTcpServer::getLocalIp()
{
    QString hostName = QHostInfo::localHostName();
    QHostInfo hostInfo = QHostInfo::fromName(hostName);
    ui->plainTextEdit->appendPlainText("本机名称：" + hostName);
    QString locaIp;

    QList<QHostAddress> list = hostInfo.addresses();

    if (list.empty())
        return "null QString";

    foreach (QHostAddress addr, list) {
        if (addr.protocol() == QAbstractSocket::IPv4Protocol) {
            locaIp = addr.toString();
            break;
        }
    }

    return locaIp;
}

void ExTcpServer::closeEvent(QCloseEvent *event)   //关闭窗口时候停止监听
{
    if (m_tcpServer->isListening())
        m_tcpServer->close();

    event->accept();
}

void ExTcpServer::on_actStart_triggered()
{
    QString Ip = ui->comboBox->currentText();
    quint16 port = ui->spinBox->value();

    QHostAddress addr(Ip);
    m_tcpServer->listen(addr, port);  //监听指定的 IP 和指定的 port
    ui->plainTextEdit->appendPlainText("服务器地址为:" + m_tcpServer->serverAddress().toString() + "   服务器端口：" + QString::number(m_tcpServer->serverPort()));
    ui->plainTextEdit->appendPlainText("开始监听...");

    ui->actStart->setEnabled(false);
    ui->actStop->setEnabled(true);
    m_labListen->setText("监听状态：正在监听...");
}

void ExTcpServer::on_actStop_triggered()
{
    if (!m_tcpServer->isListening())
        return;

    m_tcpServer->close();  //停止监听

    ui->actStart->setEnabled(true);
    ui->actStop->setEnabled(false);
    m_labListen->setText("监听状态：监听已经停止");
}

void ExTcpServer::on_actClear_triggered()
{
    ui->plainTextEdit->clear();
}

void ExTcpServer::on_actQuit_triggered()
{
    close();
}

void ExTcpServer::on_btnSend_clicked()
{
    QString msg = ui->lineEdit->text();
    ui->plainTextEdit->appendPlainText("[服务器:]" + msg);
    ui->lineEdit->clear();
    ui->plainTextEdit->hasFocus();

    QByteArray str = msg.toUtf8();
    str.append('\n');
    m_tcpSocket->write(str);
}

void ExTcpServer::onSocketReadyRead()     //读取缓冲区行文本
{
    while (m_tcpSocket->canReadLine()) {
        ui->plainTextEdit->appendPlainText("[客户端:]" + m_tcpSocket->readLine());
    }
}

void ExTcpServer::onClientConnected()    //客户端连接时
{
    ui->plainTextEdit->appendPlainText("客户端套接字连接\n对等(peer)地址：" + m_tcpSocket->peerAddress().toString()
                                       + "    对等(peer)端口：" +  QString::number(m_tcpSocket->peerPort()));

}

void ExTcpServer::onClientDisonnected()  //客户端断开连接时
{
    ui->plainTextEdit->appendPlainText("客户端套接字断开");
    m_tcpSocket->deleteLater();
}

void ExTcpServer::onNewConnection()
{
    m_tcpSocket = m_tcpServer->nextPendingConnection();   //创建 socket

    connect(m_tcpSocket, SIGNAL(connected()), this, SLOT(onClientConnected()));
    connect(m_tcpSocket, SIGNAL(disconnected()), this, SLOT(onClientDisonnected()));
    connect(m_tcpSocket, SIGNAL(stateChanged(QAbstractSocket::SocketState)), this, SLOT(onSocketStateChange(QAbstractSocket::SocketState)));
    onSocketStateChange(m_tcpSocket->state());
    connect(m_tcpSocket, SIGNAL(readyRead()), this, SLOT(onSocketReadyRead()));
}

void ExTcpServer::onSocketStateChange(QAbstractSocket::SocketState socketState)
{
    switch (socketState) {
    case QAbstractSocket::UnconnectedState:
        m_labSocket->setText("socket状态：UnconnectedState");
        break;
    case QAbstractSocket::HostLookupState:
        m_labSocket->setText("socket状态：HostLookupState");
        break;
    case QAbstractSocket::ConnectingState:
        m_labSocket->setText("socket状态：ConnectingState");
        break;
    case QAbstractSocket::ConnectedState:
        m_labSocket->setText("socket状态：ConnectedState");
        break;
    case QAbstractSocket::BoundState:
        m_labSocket->setText("socket状态：BoundState");
        break;
    case QAbstractSocket::ClosingState:
        m_labSocket->setText("socket状态：ClosingState");
        break;
    case QAbstractSocket::ListeningState:
        m_labSocket->setText("socket状态：ListeningState");
        break;
    default:
        m_labSocket->setText("socket状态：其他未知状态...");
        break;
    }
}

其中客户端：

#ifndef EXTCPCLIENT_H
#define EXTCPCLIENT_H

#include <QMainWindow>
#include <QLabel>
#include <QTcpSocket>
#include <QHostInfo>

namespace Ui {
class ExTcpClient;
}

class ExTcpClient : public QMainWindow
{
    Q_OBJECT

public:
    explicit ExTcpClient(QWidget *parent = nullptr);
    ~ExTcpClient();

private:
    QString getLocalIp();                  //获取本本机 IP

protected:
    void closeEvent(QCloseEvent *event);

private slots:
    //UI 定义的槽函数
    void on_actConnect_triggered();     //请求连接到服务器
    void on_actDisconnect_triggered();  //断开与服务器的连接
    void on_actClear_triggered();       //清除内容
    void on_actQuit_triggered();        //退出程序
    void on_btnSend_clicked();          //发送文本消息

    //自定义的槽函数
    void onConnected();
    void onDisconnected();
    void onSocketReadyRead();           //从socket读取传入的数据
    void onSocketStateChange(QAbstractSocket::SocketState socketState);

private:
    Ui::ExTcpClient *ui;

    QLabel* m_labSocket;
    QTcpSocket* m_tcpSocket;
};

#endif // EXTCPCLIENT_H


#include "ExTcpClient.h"
#include "ui_ExTcpClient.h"

ExTcpClient::ExTcpClient(QWidget *parent) :
    QMainWindow(parent),
    ui(new Ui::ExTcpClient)
{
    ui->setupUi(this);

    m_labSocket = new QLabel("socket状态：");
    m_labSocket->setMidLineWidth(150);
    ui->statusBar->addWidget(m_labSocket);

    m_tcpSocket = new QTcpSocket(this);

    QString localIp = getLocalIp();
    this->setWindowTitle(windowTitle() + "----本机IP:" + localIp);
    ui->comboBox->addItem(localIp);

    connect(m_tcpSocket, SIGNAL(connected()), this, SLOT(onConnected()));
    connect(m_tcpSocket, SIGNAL(disconnected()), this, SLOT(onDisconnected()));
    connect(m_tcpSocket, SIGNAL(stateChanged(QAbstractSocket::SocketState)), this, SLOT(onSocketStateChange(QAbstractSocket::SocketState)));
    connect(m_tcpSocket, SIGNAL(readyRead()), this, SLOT(onSocketReadyRead()));
}

ExTcpClient::~ExTcpClient()
{
    delete ui;
}

QString ExTcpClient::getLocalIp()
{
    QString hostName = QHostInfo::localHostName();
    QHostInfo hostInfo = QHostInfo::fromName(hostName);
    ui->plainTextEdit->appendPlainText("本机名称：" + hostName);
    QString localIp;

    foreach (QHostAddress addr, hostInfo.addresses()) {
        if (QAbstractSocket::IPv4Protocol == addr.protocol()) {
            localIp = addr.toString();
            break;
        }
    }
    return localIp;
}

void ExTcpClient::closeEvent(QCloseEvent *event)
{
    if (m_tcpSocket->state() == QAbstractSocket::ConnectedState)
        m_tcpSocket->disconnectFromHost();

    event->accept();
}

void ExTcpClient::onConnected()
{
    ui->plainTextEdit->appendPlainText("已经连接到服务器\n客户端套接字连接\n对等(peer)地址：" + m_tcpSocket->peerAddress().toString()
                                       + "    对等(peer)端口：" +  QString::number(m_tcpSocket->peerPort()));
    ui->actConnect->setEnabled(false);
    ui->actDisconnect->setEnabled(true);
}

void ExTcpClient::onDisconnected()
{
    ui->plainTextEdit->appendPlainText("已经断开与服务器的连接\n");
    ui->actConnect->setEnabled(true);
    ui->actDisconnect->setEnabled(false);
}

void ExTcpClient::onSocketReadyRead()
{
    while (m_tcpSocket->canReadLine()) {
        ui->plainTextEdit->appendPlainText("[服务器:]" + m_tcpSocket->readLine());
    }
}

void ExTcpClient::onSocketStateChange(QAbstractSocket::SocketState socketState)
{
    switch (socketState) {
    case QAbstractSocket::UnconnectedState:
        m_labSocket->setText("socket状态：UnconnectedState");
        break;
    case QAbstractSocket::HostLookupState:
        m_labSocket->setText("socket状态：HostLookupState");
        break;
    case QAbstractSocket::ConnectingState:
        m_labSocket->setText("socket状态：ConnectingState");
        break;
    case QAbstractSocket::ConnectedState:
        m_labSocket->setText("socket状态：ConnectedState");
        break;
    case QAbstractSocket::BoundState:
        m_labSocket->setText("socket状态：BoundState");
        break;
    case QAbstractSocket::ClosingState:
        m_labSocket->setText("socket状态：ClosingState");
        break;
    case QAbstractSocket::ListeningState:
        m_labSocket->setText("socket状态：ListeningState");
        break;
    default:
        m_labSocket->setText("socket状态：其他未知状态...");
        break;
    }
}

void ExTcpClient::on_actConnect_triggered()
{
    QString addr = ui->comboBox->currentText();
    quint16 port = ui->spinBox->value();
    m_tcpSocket->connectToHost(addr, port);
}

void ExTcpClient::on_actDisconnect_triggered()
{
    if(m_tcpSocket->state() == QAbstractSocket::ConnectedState)
        m_tcpSocket->disconnectFromHost();
}

void ExTcpClient::on_actClear_triggered()
{
    ui->plainTextEdit->clear();
}

void ExTcpClient::on_actQuit_triggered()
{
    close();
}

void ExTcpClient::on_btnSend_clicked()
{
    QString msg = ui->lineEdit->text();
    ui->plainTextEdit->appendPlainText("[客户端:]" + msg);
    ui->lineEdit->clear();
    ui->lineEdit->setFocus();

    QByteArray str = msg.toUtf8();
    str.append('\n');
    m_tcpSocket->write(str);
}

源码下载：

https://github.com/xmuli/QtExamples【QtTcpEx】

偕臧x
关注
  • 9
    点赞
  • 踩
  • 40
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 2
    评论
专栏目录
Qt——Qt网络编程之TCP通信服务器端的实现（使用QTcpServer、QTcpSocket实现一个TCP服务器端例程）
数字世界 万物互联
04-18 179
TCP 协议（Transmission Control Protocol）全称是传输控制协议，是一种面向连接的、可靠的、基于字节流的传输层通信协议。TCP 通信必须先建立 TCP 连接，通信端分为客户端和服务端。服务端通过监听某个端口来监听是否有客户端连接到来，如果有连接到来，则建立新的socket 连接；客户端通过 ip 和port 连接服务端，当成功建立连接之后，就可进行数据的收发了。 在 Qt 中，Qt 把 socket 当成输入输出流来对待的，数据的收发是通过 re
Tcp通信服务器端和客户端
12-27
本项目提供的"Tcp通信服务器端和客户端"涵盖了TCP通信的基本原理和实现方式，特别地，它与Qt库结合，使得开发更高效且用户友好。 首先，TCP服务器端是接收客户端连接并处理请求的程序。在TCP连接的三次握手过程中，...
Roson的Qt之旅 #116 QTcpServer详细介绍
Allen Roson
09-15 1828
QTcpServer详细介绍；Qt TCP编程；Qt TCP通讯
使用Qt实现TCP服务器和客户端
最新发布
高性价比服务器就选：蓝易云
05-13 812
现在，TCP服务器可以接收来自客户端的文本，客户端也可以收到服务器的响应。这个教程提供了一个简单易懂的范例，您可以通过扩展其功能，来满足您的实际项目需求。首先，安装和设置Qt开发环境。推荐使用Qt Creator IDE。确保已安装Qt Network模块，因为它包含用于网络编程的类。使用Qt框架可以实现TCP服务器和客户端的功能。本教程将通过构建简单的TCP服务器和客户端示例来说明如何使用Qt进行通信。一、创建TCP服务器。二、创建TCP客户端。
【QT】TCP通信（QTcpServer 和 QTcpSocket）
瞌睡的博客
02-13 4504
TCP是一种被大多数Internet网络协议（如HTTP）用于数据传输的低级网络协议，它是可靠的、面向流、面向连接的传输协议，特别适合于连续数据传输。TCP通信必须先建立TCP连接，分为服务器端和客户端。Qt提供QTcpServer类和QTcpSocket类用于建立TCP通信。服务器端必须使用QTcpServer用于端口监听，建立服务器；QTcpSocket用于建立连接后使用套接字进行通信。
最简洁完整的Qt服务器和客户端TCP通讯代码
lish472961320的博客
04-09 263
首先调用listen()让服务器侦听传入的连接。然后再调用nextPendingConnection()以接受挂起的连接作为已连接的QTcpSocket。QTcpServer提供了一个基于TCP的服务器，允许接受传入的TCP连接。首先调用connectToHost连接服务器，会发送一个connected()信号。然后通过read()和write()可以接受和写入需要传输的数据。其中为了可以实现自动互相发送消息，使用了Qt的Timer对象，每5秒客户端向服务器发送消息，同时服务器也会向连接的客户端发送消息。
QTcpSocket和QTcpServer的理解和使用
weixin_41377572的博客
03-08 524
QTcp的基本使用
QT学习笔记之TCP通信3（TCP服务器与客户端数据互传）
Yz12333的博客
04-19 2467
本文介绍了Qt中TCP通信的实现，涉及QTcpServer和QTcpSocket两个核心类。QTcpServer用于建立TCP服务器，监听端口并接受客户端连接；QTcpSocket则用于创建TCP客户端或处理服务器新连接。文中展示了服务器监听端口、接收连接、数据传输和客户端连接服务器、数据传输的过程。同时，讨论了TCP服务器与客户端的联调步骤，包括运行工程、查看本机地址、连接和数据互传。最后，总结了在TCP通信中可能遇到的问题及其解决方案，如端口号使用、服务器关闭后客户端数据传输问题，以及端口号有效性验证。
Qt：58---网络编程之TCP（QTcpServer、QTcpSocket）
董哥的黑板报
08-29 1664
一、TCP特点 是可靠的、面向流、面向连接饿传输协议，适合用于连续数据传输 三次握手 服务端和客户端建立稳定的传输通道，需要3个步骤 客户端向服务器发送信息，发送一个报文(syn(请求同步)) 服务端将受到的客户端的报文重新发回去，再多加一个报文(ack(确认)) 客户端再向服务端发送报文(ack) 四次挥手 服务端和客户端断开传输通断，需要4个步骤 客户端向服务端发送报文(fin...
QT的tcp通信和本地通信（QTcpSocket和QLocalSocket）
weixin_43246170的博客
11-15 4488
在qt中TCP通信是使用QTcpSocket和QTcpServer来实现的。 本地通信是使用QLocalSocket和QlocalServer来实现的。 tcp通信： 服务器： 1、创建服务器对象QTcpServer。 2、配置服务器对象的信号槽newConnection()，捕获客户端连接。 3、listen监听客户端（监听参数ip和端口）。 4、如果有客户端连接，创建QTcpSocket来获取客户端对象。 5、配置客户端对象的信号槽readyRead()，捕获客户端发送数据。 客户端： 1、创建客户端对
使用QTcpServer和QTcpSocket实现了服务端和客户端的简单通讯源码 ，只能一对一通讯
09-28
QTcpServer和QTcpSocket是Qt库中的网络通信模块，用于构建基于TCP协议的服务器和客户端应用程序。在本文中，我们将深入探讨如何使用这两个类来实现一对一的简单通讯。 首先，QTcpServer是一个用于监听和接受来自多...
Qt Tcp通讯发送文字、文件QTcpsocket、QTcpserver
07-22
在本文中，我们将深入探讨如何使用Qt库中的QTcpSocket和QTcpServer控件来实现TCP通信，包括发送文字和文件。Qt是一个跨平台的C++应用程序开发框架，提供了丰富的功能，包括网络编程接口，使得我们可以方便地进行TCP...
QT——服务器+客户端进行tcp通信代码.rar
12-23
在"QT——服务器+客户端进行tcp通信代码.rar"这个压缩包中，包含了一个客户端（client）和一个服务器端（server）的工程，这让我们有机会深入理解QT如何实现TCP/IP通信。 首先，TCP（传输控制协议）是互联网协议栈...
一个简单的QT tcp客户端和服务器端的相互通信
08-06
客户端则使用`QTcpSocket`类主动连接到服务器端的IP地址和端口号。一旦连接建立成功，同样可以通过该对象进行数据的发送和接收。在GUI界面上，通常会有一个输入框用于用户输入要发送的数据，以及一个显示区域用于...
在win10环境下安装QtCreator5.9.8作为c++的IDE开发工具
12-23 7515
简 述： 在 windows10环境下安装Qt Creator5.9.8作为c++的 IDE开发工具，学习和使用 qt框架学习 文章目录系统环境：下载QtCreator：安装QtCreator：验证安装成功：推荐关闭插件： 本篇的csdn/github.io同步博文: 系统环境： 编程环境： win10 x64 专业版 1903 编程软件： Qt 5.9.8，Qt Creato...
QtExamples 系列目录
08-29 7049
Qt 之 GUI 控件使用 / 网络 / 架构原理 / 运行机制理解；DTK 重绘控件方式的框架解析；IDE 技巧之 Visual Studio / Qt Creator；此为系列文章教程
QTableView和QStandardItemModel(以及代理的例子)的用法
12-17 6708
简 述： 继续学习QTableView和QStandardItemModel的用法，以及这里例子里面有具体使用代理的例子（模型-视图-代理），其中专门给代理写一成一个类来实现他们；书写一个简单的Qt例子????，用来实现和验证它的控件的一些属性和功能的用法。 文章目录系统环境：QStandardItemModel：QTableView：QItemSelectionModel:设计思路：运行效果：...
qt tcp服务器和客户端同时运行
08-23
Qt是一个跨平台的应用程序开发框架，它可以用来开发各种类型的应用程序，包括TCP服务器和客户端。 在Qt中，可以使用Qt网络模块来实现TCP服务器和客户端的功能。要同时运行TCP服务器和客户端，可以在同一个应用程序中创建两个Qt网络对象，分别用于实现服务器和客户端的功能。 首先，我们需要创建一个QTcpServer对象来实现TCP服务器的功能。通过调用QTcpServer的listen()函数来监听指定的IP地址和端口号，等待客户端的连接请求。当有新的客户端连接时，QTcpServer会自动发出newConnection()信号，我们可以通过连接这个信号的槽函数来处理新客户端的连接。 然后，我们需要创建一个QTcpSocket对象来实现TCP客户端的功能。通过调用QTcpSocket的connectToHost()函数来连接到服务器的IP地址和端口号。连接成功后，我们可以发送和接收数据。 在应用程序中，可以创建一个主窗口，同时创建一个QTcpServer对象和一个QTcpSocket对象。在主窗口中，可以增加一些用户界面元素，例如按钮和文本框，用于操作服务器和客户端。当点击按钮时，可以通过QTcpServer和QTcpSocket对象来实现相应的功能，例如启动服务器、连接到服务器、发送数据等。 需要注意的是，在同一个应用程序中同时运行TCP服务器和客户端可能需要一些线程管理的技术，以保证服务器和客户端之间的通信不会阻塞主线程的运行。可以使用Qt的多线程技术来实现这一点，例如将服务器和客户端的功能代码放在不同的线程中运行。 总而言之，通过使用Qt的网络模块，可以很方便地实现TCP服务器和客户端的功能，并在同一个应用程序中同时运行它们。
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

偕臧x

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值