QT 项目 实现基于TCP的文件服务器/客户端，支持上传和下载

最新推荐文章于 2024-04-12 18:43:11 发布
最新推荐文章于 2024-04-12 18:43:11 发布
阅读量3.9k 收藏 74
点赞数 18
分类专栏： 项目
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/guorong520/article/details/101058504
版权

Demo：下载地址: https://download.csdn.net/download/guorong520/12408371
没有csdn积分的小伙伴可以留言你的QQ邮箱，我会发送Demo，相互交流学习

一、程序运行图
客户端
在这里插入图片描述
服务端
在这里插入图片描述

二、功能描述
1.开启服务器，客户端进行连接。
2.客户端向服务器上传文件，也可以下载服务器文件到客户端本地。

三、源码如下
1.客户端
Client.cpp

#include "Client.h"
#include "ui_Client.h"

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

    initClient();

    //1.上传
    connect(this, &Client::changeUpText, ui->labelUpTip, &QLabel::setText);
    connect(ui->btnConnect,&QPushButton::clicked,this,&Client::onConnect);
    connect(m_client,&QTcpSocket::connected,this,&Client::onAcceptState);
    connect(ui->btnUpload,SIGNAL(clicked(bool)),this,SLOT(onOpenFile()));
    connect(ui->btnSend,&QPushButton::clicked,this,&Client::onSendFile);
    //第一：此信号，不能写入局部函数中，其他函数可以执行此信号，但是参数仍保留上一次的值。
    //第二：触发此信号，不会立即执行槽函数，执行完这个局部函数，才会执行槽函数。
    //第三：信号槽不能重复定义
    connect(m_client, SIGNAL(bytesWritten(qint64)),this, SLOT(updateProgress(qint64)));

    //2.下载
    connect(this, &Client::changePuText, ui->labelPuTip, &QLabel::setText);
    connect(ui->btnRemote,&QPushButton::clicked,this,&Client::onResquestFileList);
    connect(ui->listWidget,&QListWidget::itemSelectionChanged,this,&Client::onGetDownFileName);
    connect(ui->btnDownload,&QPushButton::clicked,this,&Client::onDownRequest);
    connect(m_client, &QTcpSocket::readyRead, this, &Client::onReceiveProgress);

}

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

void Client::initClient()
{
	setWindowTitle("文件客户端");
    ui->labelUpTip->setText(QString("请先连接:"));

	m_client = new QTcpSocket(this);
	m_totalBytes = 0;
	m_bytesWritten = 0;
	m_bytesTobeWrite = 0;
    m_cmd = 0;
    m_payloadSize = 64 * 1024;
    ui->progressBar->reset();
}

void Client::onConnect()
{
    if(ui->editHost->text().isEmpty() || ui->editPort->text().isEmpty())
    {
        QMessageBox::information(this,"提示"," 主机和端口不能为空");
        return;
    }
    emit changeUpText(QString("连接中"));
    m_client->connectToHost(ui->editHost->text(),ui->editPort->text().toInt());
    if(!m_client->waitForConnected(30000))
    {
        emit changeUpText(QString("连接失败!"));
    }
}

void Client::onAcceptState()
{
    emit changeUpText(QString("连接成功！"));
}

void Client::onOpenFile()
{
    emit changeUpText(QString("等待打开文件:"));
    m_fileName = QFileDialog::getOpenFileName(this);

    if(!m_fileName.isEmpty())
    {
        emit changeUpText(QString("文件 %1 打开成功！").arg(m_fileName));
    }
}

void Client::onSendFile()
{
    //不是消息，并且文件名为空
    if(m_cmd == 0 && m_fileName.isEmpty())
    {
        ui->labelUpTip->setText("请选择上传文件");
        return;
    }

    m_localFile = new QFile(m_fileName);
    if(!m_localFile->open(QFile::ReadOnly))
    {
        qDebug()<<"文件打开错误";
    }
    //计算文件大小
    m_totalBytes = m_localFile->size();

    //将发送缓冲区封装在QDataStream类型的变量中，方便传输数据
    QDataStream sendOut(&m_outBlock,QIODevice::WriteOnly);
    sendOut.setVersion(QDataStream::Qt_5_7);

    //构造临时文件头(总文件大小+文件名大小+消息类型+文件名)
    sendOut<<qint64(0)<<qint64(0)<<qint64(0)<<clearFilePath(m_fileName);;
    //计算文件总大小(总文件大小 = 文件大小 + 文件名 + sizeof(qint64)*3))
    m_totalBytes += m_outBlock.size();

    //将读写操作指向从头开始
    sendOut.device()->seek(0);
    //总大小和文件名大小和命令(必须为八个字节格式，里面存放值)
    sendOut<<m_totalBytes<<qint64((m_outBlock.size()-sizeof(qint64)*3))<<qint64(UPLOAD_FILE);
    m_cmd = UPLOAD_FILE;
    qDebug()<<"发送总大小"<<m_totalBytes<<"文件名大小"<<qint64((m_outBlock.size()-sizeof(qint64)*3))
           <<"文件名称"<<m_fileName<<"命令"<<m_cmd-3840;

    //修改待发送字节数
    m_bytesTobeWrite = m_totalBytes - m_client->write(m_outBlock); 
    m_outBlock.resize(0);
}

void Client::updateProgress(qint64 numBytes)
{
    //发送文件内容
    m_bytesWritten += numBytes;

    if(m_bytesTobeWrite > 0)
    {
        //100<200?100:200
        m_outBlock = m_localFile->read(qMin(m_bytesTobeWrite,m_payloadSize));
        m_bytesTobeWrite -= m_client->write((m_outBlock));
        m_outBlock.resize(0);
    }
    else
    {
        m_localFile->close();
    }

    ui->progressBar->setMinimum(0);
    ui->progressBar->setMaximum(100);
    ui->progressBar->setValue(m_bytesWritten*100/m_totalBytes);

    if(m_bytesWritten == m_totalBytes)
    {
        qDebug()<<"发送总大小："<<m_totalBytes<<"已发送"<<m_bytesWritten<<"待发送"<<m_bytesTobeWrite;
        if(m_cmd == UPLOAD_FILE)
        {
            ui->labelUpTip->setText(QString("传送文件%1成功").arg(m_fileName));
        }
        if(m_cmd == SYN_FILE_LIST)
        {
            ui->labelPuTip->setText("请求同步列表已发送！");
        }
        if(m_cmd == DOWNLOAD_FILE)
        {
            ui->labelPuTip->setText("请求下载文件已发送！");
        }

        m_totalBytes = 0;
        m_bytesWritten = 0;
        m_bytesTobeWrite = 0;
        m_bytesReceived = 0;
        m_fileNameSize = 0;
        m_fileName = "";
        m_cmd = 0;
        m_outBlock.resize(0);
        m_localFile->close();
    }
}

void Client::onResquestFileList()
{
    m_localFile = new QFile("");
    if(!m_localFile->open(QFile::ReadOnly))
    {
        m_localFile->close();
    }
    QDataStream sendOut(&m_outBlock,QIODevice::WriteOnly);
    sendOut.setVersion(QDataStream::Qt_5_7);
    QString curFile = "";
    //构造临时文件头(总文件大小+文件名大小+消息类型+文件名)
    sendOut<<qint64(0)<<qint64(0)<<qint64(0)<<curFile;
    //计算文件总大小(总文件大小 = 文件大小 + 文件名 + sizeof(qint64)*3))
    m_totalBytes += m_outBlock.size();

    //将读写操作指向从头开始
    sendOut.device()->seek(0);
    //总大小和文件名大小和命令
    sendOut<<m_totalBytes<<qint64((m_outBlock.size()-sizeof(qint64)*3))<<qint64(SYN_FILE_LIST);
    m_cmd = SYN_FILE_LIST;
    qDebug()<<"发送总大小"<<m_totalBytes<<"文件名大小"<<qint64((m_outBlock.size()-sizeof(qint64)*3))
           <<"文件名称"<<m_fileName<<"命令"<<m_cmd-3840;

    //修改待发送字节数
    m_bytesTobeWrite = m_totalBytes - m_client->write(m_outBlock);
    displayFileList();
}

void Client::displayFileList()
{
    QString filePath = QApplication::applicationDirPath() + "/../../tcpClientFile/LocalFile";
    QDir dir(filePath);
    filePath = dir.absolutePath() + "/FILELIST.TXT";
    QFile fileList(filePath);
    if(!fileList.open(QFile::ReadOnly|QFile::Text))
    {
        qDebug()<<"Client::displayFileList :open filelist.txt error!"<<endl;
        return;
    }

    QTextStream input(&fileList);
    QString line;
    ui->listWidget->clear();
    while(input.readLineInto(&line))    //把所有文件名进行显示
    {
        //Qt中是编码格式是UTF-8-BOM
        ui->listWidget->addItem(line);
    }
}

QString Client::clearFilePath(QString filePath)
{
    QString fileName = filePath.right(filePath.size() - filePath.lastIndexOf('/')-1);
    return fileName;
}

void Client::onGetDownFileName()
{
    m_downFileName = ui->listWidget->currentItem()->text();

}

void Client::onDownRequest()
{
    if(m_downFileName.isEmpty())
    {
        ui->labelPuTip->setText("请先选择需要下载的文件");
        return;
    }
    m_localFile = new QFile("");
    if(!m_localFile->open(QFile::ReadOnly))
    {
        m_localFile->close();
    }
    QDataStream sendOut(&m_outBlock,QIODevice::WriteOnly);
    sendOut.setVersion(QDataStream::Qt_5_7);
    QString curFile = m_downFileName;
    //构造临时文件头(总文件大小+文件名大小+消息类型+文件名)
    sendOut<<qint64(0)<<qint64(0)<<qint64(0)<<curFile;
    //计算文件总大小(总文件大小 = 文件大小 + 文件名 + sizeof(qint64)*3))
    m_totalBytes += m_outBlock.size();

    //将读写操作指向从头开始
    sendOut.device()->seek(0);
    //总大小和文件名大小和命令
    sendOut<<m_totalBytes<<qint64((m_outBlock.size()-sizeof(qint64)*3))<<qint64(DOWNLOAD_FILE);
    m_cmd = DOWNLOAD_FILE;
    qDebug()<<"发送总大小"<<m_totalBytes<<"文件名大小"<<qint64((m_outBlock.size()-sizeof(qint64)*3))
           <<"文件名称"<<m_fileName<<"命令"<<m_cmd-3840;

    //修改待发送字节数
    m_bytesTobeWrite = m_totalBytes - m_client->write(m_outBlock);
}

void Client::onReceiveProgress()
{
    QDataStream in(m_client);

    in.setVersion(QDataStream::Qt_5_7);
    // 如果已接收到的数据小于等于24个字节，保存文件头结构

    if (m_bytesReceived<=sizeof(qint64)*3){
        //先取24个字节（bytesAvailable：套接字中的数据）
        if((m_client->bytesAvailable()>=sizeof(qint64)*3)&&(m_fileNameSize==0)){
            // 接收数据总大小信息和文件名大小信息
            in>>m_totalBytes>>m_fileNameSize>>m_cmd;
            m_bytesReceived +=sizeof(qint64)*3;
        }
        if((m_client->bytesAvailable()>=m_fileNameSize)&&(m_fileNameSize!=0)){
            // 接收文件名，并建立文件
            in>>m_fileName;
            m_bytesReceived+=m_fileNameSize;
            if(m_cmd == UPLOAD_FILE)
            {
                ui->labelPuTip->setText(tr("接收文件 %1 …").arg(m_fileName));
                //创建同名文件
                QString filePath = QApplication::applicationDirPath() + "/../../tcpClientFile/LocalFile";
                QDir dir(filePath);
                filePath = dir.absolutePath() + QString("/%1").arg(m_fileName);
                m_localFile = new QFile(filePath);

                if (!m_localFile->open(QFile::WriteOnly)){
                    qDebug() << "Server::onReceiveProgress: open file error!";
                    return;
                }
            }
        }
        else{
            return;
        }
        qDebug()<<"接收头部数据："<<"总大小"<<m_totalBytes<<"头部大小"<<m_bytesReceived<<"命令"<<m_cmd-3840
               <<"文件名"<<m_fileName;
    }

    // 如果接收的数据小于总数据，那么写入文件
    if(m_bytesReceived<m_totalBytes) {
        m_bytesReceived+=m_client->bytesAvailable();
        m_inBlock = m_client->readAll();
        //
        m_localFile->write(m_inBlock);
        m_inBlock.resize(0);
    }

    ui->progressBar->setMinimum(0);
    ui->progressBar->setMaximum(100);
    ui->progressBar->setValue(m_bytesReceived*100/m_totalBytes);

    // 接收数据完成时,字段初始化，否则无法接收
    if (m_bytesReceived==m_totalBytes){
        qDebug()<<"接收文件内容："<<"总大小"<<m_totalBytes<<"已接收"<<m_bytesReceived<<"文件名"<<m_fileName;
        if(m_cmd == UPLOAD_FILE)
        {
            ui->labelPuTip->setText(tr("接收文件 %1 成功！").arg(m_fileName));
            m_localFile->close();
            m_totalBytes = 0;
            m_bytesWritten = 0;
            m_bytesTobeWrite = 0;
            m_bytesReceived = 0;
            m_fileName = "";
            m_downFileName = "";
            m_cmd = 0;
            m_payloadSize = 64 * 1024;
            ui->progressBar->reset();
        }
        displayFileList();
    }
}

服务端
Server.cpp

#include "Server.h"
#include "ui_Server.h"
#include <QDir>

Server::Server(QWidget *parent) :
    QDialog(parent),
    ui(new Ui::Server)
{
    ui->setupUi(this);
    setWindowTitle("文件服务器");
    initServer();

    connect(ui->btnListen,&QPushButton::clicked,this,&Server::onStart);
    connect(ui->btnClose, &QPushButton::clicked, this , &Server::close);
    connect(&m_tcpServer,&QTcpServer::newConnection,this,&Server::onAcceptConnected);
    connect(&m_tcpServer,&QTcpServer::acceptError,this,&Server::displayError);
}

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

void Server::initServer()
{
    m_fileNameSize = 0;
    m_totalBytes = 0;
    m_bytesReceived = 0;

    m_bytesWritten = 0;
    m_bytesTobeWrite = 0;

    //系统最大为64K，但可以自行修改系统设置
    m_payLoadSize = 64 * 1024;
    m_cmd = 0;
    m_tcpSocket = new QTcpSocket(this);
}

void Server::onStart()
{
    ui->labelTip->setText(QString("开始监听!"));
    if(!m_tcpServer.listen(QHostAddress::Any,PORT))
    {
        ui->labelTip->setText(QString("%1").arg(m_tcpServer.errorString()));
        m_tcpServer.close();
    }
}

void Server::onAcceptConnected()
{
    ui->labelTip->setText("连接成功！");
    m_tcpSocket = m_tcpServer.nextPendingConnection();
    //系统信号:readyRead/bytesWritten
    connect(m_tcpSocket, &QTcpSocket::readyRead, this, &Server::onReceiveProgress);
    connect(m_tcpSocket, SIGNAL(bytesWritten(qint64)),this, SLOT(onUpdateSendProgress(qint64)));
}

void Server::onReceiveProgress()
{
    //1.传输大文件时，界面不会卡住
    qApp->processEvents();
    QDataStream in(m_tcpSocket);
    in.setVersion(QDataStream::Qt_5_7);

    //2.如果已接收到的数据小于等于24个字节，保存文件头结构
    if (m_bytesReceived<=sizeof(qint64)*3)
    {
        if((m_tcpSocket->bytesAvailable()>=sizeof(qint64)*3)&&(m_fileNameSize==0))
        {
            //(1)接收数据总大小和文件名大小和命令
            in>>m_totalBytes>>m_fileNameSize>>m_cmd;
            m_bytesReceived +=sizeof(qint64)*3;
        }
        if((m_tcpSocket->bytesAvailable()>=m_fileNameSize)&&(m_fileNameSize!=0))
        {
            //(2)接收文件名
            in>>m_fileName;
            m_bytesReceived+=m_fileNameSize;

            //(3)解析命令：收到消息不处理，收到客户端上传命令建立文件
            if(m_cmd == UPLOAD_FILE)
            {
                ui->labelTip->setText(tr("接收文件 %1 …").arg(m_fileName));
                //创建同名文件
                QString filePath = QApplication::applicationDirPath() + "/../../tcpServerFile/RemoteFile";
                QDir dir(filePath);
                filePath = dir.absolutePath() + QString("/%1").arg(m_fileName);

                m_localFile = new QFile(filePath);
                if (!m_localFile->open(QFile::WriteOnly)){
                    qDebug() << "Server::onReceiveProgress: open file error!";
                    return;
                }
            }
        }
        else
        {
            return;
        }
        qDebug()<<"接收头部数据："<<"总大小"<<m_totalBytes<<"头部大小"<<m_bytesReceived<<"命令"<<m_cmd-3840
               <<"文件名"<<m_fileName;
    }

    // 如果接收的数据小于总数据，那么写入文件
    if(m_bytesReceived<m_totalBytes) {
        m_bytesReceived+=m_tcpSocket->bytesAvailable();
        m_inBlock = m_tcpSocket->readAll();
        m_localFile->write(m_inBlock);
        m_inBlock.resize(0);
    }

    ui->progressBar->setMinimum(0);
    ui->progressBar->setMaximum(100);
    ui->progressBar->setValue(m_bytesReceived*100/m_totalBytes);

    // 接收数据完成时,字段初始化，防止数据污染
    if (m_bytesReceived == m_totalBytes)
    {
        qDebug()<<"接收文件内容："<<"总大小"<<m_totalBytes<<"已接收"<<m_bytesReceived<<"文件名"<<m_fileName;
        if(m_cmd == UPLOAD_FILE)
        {
            ui->labelTip->setText(tr("接收文件 %1 成功！").arg(m_fileName));
            m_localFile->close();
            clearVar();
        }

        if(m_cmd == SYN_FILE_LIST)
        {
            ui->labelTip->setText("客户端请求文件同步列表");
            clearVar();
            getRemoteFileList();
            sendFile();
        }
        if(m_cmd == DOWNLOAD_FILE)
        {
            ui->labelTip->setText("客户端请求下载文件");
            clearVar();
            sendFile();
        }
    }
}

void Server::sendFile()
{
    if(m_cmd == SYN_FILE_LIST)
    {
        qDebug()<<"客户端请求远程文件列表";
        QString fileList = QApplication::applicationDirPath() + "/../../tcpServerFile";
        QDir dir(fileList);
        fileList = dir.absolutePath() + "/FILELIST.TXT";
        m_fileName = fileList;
    }

    if(m_cmd == DOWNLOAD_FILE)
    {
        qDebug()<<"客户端请求下载远程文件";
        QString fileList = QApplication::applicationDirPath() + "/../../tcpServerFile/RemoteFile";
        QDir dir(fileList);
        fileList = dir.absolutePath() + QString("/%1").arg(m_fileName);
        m_fileName = fileList;
    }

    qDebug()<<"发送文件名称："<<m_fileName;
    m_localFile = new QFile(m_fileName);
    if(!m_localFile->open(QFile::ReadOnly))
    {
        qDebug()<<"文件打开错误";
    }
    m_totalBytes = m_localFile->size();

    QDataStream sendOut(&m_outBlock,QIODevice::WriteOnly);
    sendOut.setVersion(QDataStream::Qt_5_7);

    sendOut<<qint64(0)<<qint64(0)<<qint64(0)<<clearFilePath(m_fileName);
    //计算文件总大小(总文件大小 = 文件大小 + 文件名大小 + sizeof(qint64)*3))
    m_totalBytes += m_outBlock.size();
    qDebug()<<"发送总文件大小："<<m_totalBytes;

    //将读写操作指向从头开始
    sendOut.device()->seek(0);
    //总长度和文件总长度和命令
    sendOut<<m_totalBytes<<qint64((m_outBlock.size()-sizeof(qint64)*3))<<qint64(UPLOAD_FILE);
    m_cmd = UPLOAD_FILE;

    //修改待发送字节数
    m_bytesTobeWrite = m_totalBytes - m_tcpSocket->write(m_outBlock);
    m_outBlock.resize(0);
}

void Server::onUpdateSendProgress(qint64 numBytes)
{
    //发送文件内容
    m_bytesWritten += numBytes;

    if(m_bytesTobeWrite > 0)
    {
        //100<200?100:200
        m_outBlock = m_localFile->read(qMin(m_bytesTobeWrite,m_payLoadSize));
        m_bytesTobeWrite -= m_tcpSocket->write((m_outBlock));
        m_outBlock.resize(0);
    }
    else
    {
        m_localFile->close();
    }
    //更新回传进度条
    ui->progressBar->setMinimum(0);
    ui->progressBar->setMaximum(100);
    ui->progressBar->setValue(m_bytesWritten*100/m_totalBytes);

    if(m_bytesWritten == m_totalBytes)
    {
        ui->labelTip->setText(QString("回传文件%1成功").arg(m_fileName));
        m_totalBytes = 0;
        m_bytesWritten = 0;
        m_bytesTobeWrite = 0;
        m_cmd = 0;
        m_outBlock.resize(0);
        m_localFile->close();
    }
}

void Server::getRemoteFileList()
{
    QString fileList = QApplication::applicationDirPath() + "/../../tcpServerFile/FILELIST.TXT";
    QDir dir(fileList);
    fileList = dir.absolutePath();
    QFile f(fileList);
    QTextStream out(&f);
    if(!f.open(QFile::WriteOnly|QFile::Text))
    {
        qDebug()<<"write FILELIST.TXT error!"<<endl;
        return;
    }

    QString remotePath = QApplication::applicationDirPath() + "/../../tcpServerFile/RemoteFile";
    QDir d(remotePath);
    remotePath = d.absolutePath();
    QDir r(remotePath);
    QStringList str;
    str << "*";
    QFileInfoList files = r.entryInfoList((QStringList)"*",
                                            QDir::Files|QDir::Dirs,QDir::DirsFirst);
    for(int i=0;i<files.count();i++)
    {
        QFileInfo tmpFileInfo = files.at(i);
        QString fileName = tmpFileInfo.fileName();
        //过滤"."和".."
        if(fileName=="."||fileName=="..")
            continue;
        if(tmpFileInfo.isFile())
            //写入TXT中
            out << fileName << endl;
        else
            continue;
     }
    f.close();
}

void Server::clearVar()
{
    m_fileNameSize = 0;
    m_totalBytes = 0;
    m_bytesReceived = 0;
    m_bytesWritten = 0;
    m_bytesTobeWrite = 0;
    m_inBlock.resize(0);
    m_outBlock.resize(0);
}

QString Server::clearFilePath(QString filePath)
{
    QString fileName = filePath.right(filePath.size() - filePath.lastIndexOf('/')-1);
    return fileName;
}

void Server::displayError(QAbstractSocket::SocketError socketError)
{
    qDebug() << "Server::displayError " << socketError;
    m_tcpServer.close();
    ui->progressBar->reset();
}
daboluo520
关注
  • 18
    点赞
  • 踩
  • 74
    收藏
    觉得还不错? 一键收藏
  • 140
    评论
专栏目录
QT 基于TCP，服务器和客户端传输文件
05-31
QT开发平台下基于TCP，服务器和客户端传输文件。
Qt详解实现TCP文件传输例子（文件下载和上传）附源码
热门推荐
qq_44667165的博客
06-11 1万+
变量qint64 payloadSize用来控制每次文件读取的字节数，progressByte用来存储发送的进度，我这里一次只发送1024个字节，因为区域网传输太快了，文明小传输过程不明显，你们可以调大小，比如1024*64个字节。收到服务器发送的文件信息消息后，进行读取，获取文件名，文件大小，用文件类对象进行存储，新建准备写入一个要下载的文件，准备工作完成后，向服务器发送获取文件数据的消息。传输文件信息时，需要获取要发送的文件信息，如文件名，文件大小等，然后将这些信息发送给客户端。//是否正在下载标识。
功能强大的Qt网络请求客户端服务器源码，支持并发处理多个连接，多种回复数据格式，可自由拓展权限校验等
ReCHaFADND的博客
04-12 359
综上所述，Qt网络请求客户端服务器源码具有丰富的功能特点，灵活易用，可以满足不同场景下的网络请求需求。无论是开发者还是系统管理员，都可以利用该源码提高网络请求的效率和安全性，提供更好的用户体验。最后，该源码的代码框架整洁，注释完整，支持任意Qt版本、任意编译器、任意操作系统。第五，该源码支持8种配色方案，包括暗黑、灰黑、深绿、浅黄、深蓝、深黑、暗蓝和默认。第七，该源码对所有的请求和连接进行了计数，并将所有在线请求的IP和端口显示在表格中。其次，该源码可以设置http请求是长连接还是短连接，默认是长连接。
QT-TCP-文件传输
05-21
QT-TCP-文件传输程序
Qt实现基于TCP的文件收发
09-14
Qt下使用QTcpServer、QTcpSocket实现服务器与客户端的数据收发
QT + Tcp客户端,服务器(支持多客户端)
最新发布
05-07
QT + Tcp客户端,服务器(支持多客户端)
Qt使用QtWebApp搭建Http服务器实现文件下载
07-05
Qt使用QtWebApp搭建Http服务器实现文件下载
Qt实现TCP文件服务器（服务器发送文件）
lusanshui的博客
03-15 1748
简述 TCP文件服务器的实现，可以在TCP服务器的基础上增加文件发送逻辑。参阅TCP文件服务器的实现。【https://blog.csdn.net/lusanshui/article/details/88565806 】 代码之路 直接给出完整的TCP文件服务器代码。 MyFileServer类的头文件如下： #include &lt;QTcpServer&gt; #include &lt;QTc...
QT多线程服务器、客户端
weixin_44011306的博客
05-09 778
QT多线程服务器、客户端程序服务器dialog类（界面编写）TimeServer类（客户端连接时开启线程）TimeThread类（发送时间信息）客户端TimeClient类（获得服务器发送的时间信息）效果展示 程序 服务器 dialog类（界面编写） .h #ifndef DIALOG_H #define DIALOG_H #include <QDialog> #include &l...
基于TCP协议的文件上传与下载
qq_49194786的博客
08-07 1466
基于TCP协议的文件上传与下载
qt 下TCP文件传输
05-12
实现了qt TCP 文件传输功能，客服端发送连接请求，服务器自动推送响应的文件。本来想用来做程序的远程升级。
QT制作的tcp文件传输下载
01-27
一个tcp多线程收发工具，其中接收文件用的多线程，发送文件暂时没有用多线程，可以拿回去自己改改！各种qt版本和各种平台均亲测编译通过。
Qt使用TCP传输文件（带UI）
06-07
利用Qt实现的简单的TCP协议传输文件Demo，仅供学习与交流。
Qt TCP客户端
07-16
Qt 写的TCP客户端程序，在线程中完成数据收发，使用协议解析接口解析数据可以比较容易的更换通信协议。
Qt实现TCP文件传输例子
06-24
Qt实现TCP文件传输例子
QT基于TCP的服务器和客户端.rar
08-03
QT基于TCP协议写的服务器和客户端，用的是栈容器页面跳转，非父子窗口跳转，只初步实现了将账户的注册和登录功能，注册查重是根据账户名字，如果名字重复了，就不能继续注册，注册和登录界面还加了一个小的功能可以...
QT之TCP传输客户端和服务器端互发信息的实现
04-08
TCP传输的QT程序，包括客户端和服务器端，具体功能： 1）客户端和服务器的连接； 2）客户端往服务器发送输入的需要发送的信息，在服务器的接收显示界面显示； 3）服务器往客户端发送输入的需要发送的信息，在客户端...
Qt网络编程——TCP 服务器 客户端 代码
04-20
详见：https://blog.csdn.net/weixin_38566632/article/details/124289573 Qt网络编程——TCP 1. 概念 2. 服务器 3. 客户端 4. TCP服务器和客户端互传文件
qt实现tcp、udp服务器、客户端
11-06
Qt实现TCP和UDP服务器和客户端非常简单。Qt提供了丰富的网络功能，可以轻松地创建和管理TCP和UDP连接。 要实现一个TCP服务器，首先需要创建一个QTcpServer对象，并监听一个特定的端口。然后，使用QTcpServer的newConnection()信号连接一个槽函数，当有新的连接请求时，就会触发这个槽函数。在槽函数中，可以使用nextPendingConnection()函数接受连接，并创建一个QTcpSocket对象来处理与客户端的通信。 要实现一个TCP客户端，只需创建一个QTcpSocket对象，并调用connectToHost()函数来连接到服务器。一旦连接成功，就可以使用QTcpSocket的write()和read()函数来发送和接收数据。 要实现一个UDP服务器，需要创建一个QUdpSocket对象，并绑定到特定的端口上。通过绑定完成后，可以通过readyRead()信号连接一个槽函数，在槽函数中使用readDatagram()函数来接收数据。 要实现一个UDP客户端，只需创建一个QUdpSocket对象，并使用writeDatagram()函数来发送数据。对于接收数据，使用readyRead()信号连接一个槽函数，在槽函数中使用readDatagram()函数来接收数据。 无论是TCP还是UDP的服务器和客户端，都需要处理网络连接的建立、断开、异常等情况。使用Qt的信号和槽机制，可以很方便地处理这些情况，并进行相应的操作。 总之，Qt提供了一个易于使用的网络编程框架，可以轻松实现TCP和UDP服务器和客户端。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 140
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值