Qt-socket网络 - tcp文件传输 进阶

已于 2023-03-15 10:45:37 修改
阅读量113 收藏
点赞数
分类专栏： qt 文章标签： qt 网络 tcp/ip
于 2023-03-15 09:59:38 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/L_fengzifei/article/details/129545952
版权

Qt-socket网络 - tcp文件传输

待完善

done逻辑
datastream &file binary
传图片 Qbuffer

服务端

widget.h

#ifndef WIDGET_H
#define WIDGET_H

#include <QWidget>
#include <QTcpServer>
#include <QTcpSocket>
#include <QHostAddress>
#include <QString>
#include <QFile>
#include <QFileInfo>

QT_BEGIN_NAMESPACE
namespace Ui { class Widget; }
QT_END_NAMESPACE

class Widget : public QWidget
{
    Q_OBJECT

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

private slots:
    void on_pushButton_clicked();
    void myGetNewConnect();
    void myGetNewRead();
    void myDisconnected();

    void on_pushButton_2_clicked();

private:
    Ui::Widget *ui;
    QTcpServer *servSock;
    QTcpSocket *listenSock;
    QHostAddress servAddress;
    quint64 servPort;
    QString servSockInfo;
    QString clientSockInfo;

    bool isHead;
    QFile file;
    qint64 fileSize;
    QString fileName;
    qint64 fileNameSize;
    qint64 dataReadBytes;
    qint64 dataHeadReadBytes;

    void setFileInfo();
    qint64 BToLittleEndian(qint64 num);
    void BToLittleEndianFromByteArray(QByteArray &arr);

};
#endif // WIDGET_H

widget.cpp

#include "widget.h"
#include "ui_widget.h"

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

    ui->lineEdit->setText("127.0.0.1");
    ui->lineEdit_2->setText("8080");

    ui->pushButton_2->setEnabled(false);

    ui->progressBar->setMinimum(0);
    ui->progressBar->setMaximum(1024);
    ui->progressBar->setValue(0);

    servSockInfo=QString("%1:%2").arg(ui->lineEdit->text(),ui->lineEdit_2->text());

    servSock=new QTcpServer(this);
    listenSock=new QTcpSocket(this);

    servAddress=QHostAddress(ui->lineEdit->text());
    servPort=ui->lineEdit_2->text().toUInt();

    isHead=true;
    fileNameSize=0;
    fileSize=0;
    dataHeadReadBytes=0;
    dataReadBytes=0;
}

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


void Widget::on_pushButton_clicked()
{

    if (!servSock->listen(servAddress,servPort))
    {
        ui->textEdit->append("ERROR: server listen failed...");
        ui->textEdit->append(servSock->errorString());
        return;
    }
    connect(servSock,&QTcpServer::newConnection,this,&Widget::myGetNewConnect);
    ui->textEdit->append("server listening... waiting a connect...");

    ui->pushButton->setEnabled(false);
    ui->pushButton_2->setEnabled(true);
}


void Widget::myGetNewConnect()
{
    listenSock=servSock->nextPendingConnection();
    if (listenSock->isValid() && listenSock->isOpen())
    {
        ui->lineEdit_3->setText(listenSock->peerAddress().toString());
        ui->lineEdit_4->setText(QString::number(listenSock->peerPort()));

        clientSockInfo=QString("%1:%2").arg(ui->lineEdit_3->text(),ui->lineEdit_4->text());

        ui->textEdit->append(QString("receive a new connect request: [ %1 -> %2 ]").arg(servSockInfo,clientSockInfo));

        connect(listenSock,&QTcpSocket::readyRead,this,&Widget::myGetNewRead);
        connect(listenSock,&QTcpSocket::disconnected,this,&Widget::myDisconnected);

        listenSock->write("connect server success...");

    }
}

void Widget::myGetNewRead()
{
    /* version 1 */
    if (isHead)
    {
        if (listenSock->bytesAvailable()>=sizeof(qint64) &&
                fileNameSize==0)
        {
            QByteArray fileNameSizeArray=listenSock->read(sizeof(qint64));
            memcpy(&fileNameSize,fileNameSizeArray.data(),fileNameSizeArray.size());
            fileNameSize=BToLittleEndian(fileNameSize);
            dataHeadReadBytes+=sizeof(qint64);
        }
        if (listenSock->bytesAvailable()>=fileNameSize &&
                fileNameSize!=0)
        {
            QByteArray fileName_temp;
            qint32 fileNameSize_temp;
            QByteArray fileNameSize_temp_arr;
            fileName_temp=listenSock->read(fileNameSize+4);
            fileNameSize_temp_arr=fileName_temp.first(4);
            BToLittleEndianFromByteArray(fileNameSize_temp_arr);
            memcpy(&fileNameSize_temp,fileNameSize_temp_arr.data(),4);

            if(fileNameSize==fileNameSize_temp)
            {
                fileName=QString(fileName_temp.mid(4));
            }
            else
            {
                ui->textEdit->append("ERROR: parse the head data with fileName failed");
                return;
            }
            dataHeadReadBytes+=(fileNameSize+4);

            if (fileName.isEmpty())
            {
                ui->textEdit->append("ERROR: receive head data failed");
                return ;
            }

        }
        if (fileSize==0 && dataHeadReadBytes>sizeof(qint64) && fileNameSize!=0 &&
                listenSock->bytesAvailable()>=sizeof(qint64))
        {
            QByteArray fileSizeArray=listenSock->read(sizeof(qint64));
            memcpy(&fileSize,fileSizeArray.data(),fileSizeArray.size());
            fileSize=BToLittleEndian(fileSize);
            dataHeadReadBytes+=sizeof(qint64);

            this->setFileInfo();

            isHead=false;
        }
        else
        {
            return ;
        }
    }
    else
    {
        if (dataReadBytes<=fileSize)
        {
            qint64 dataSize=0;
            QByteArray dataArray=listenSock->readAll();
            if (!dataArray.isEmpty())
            {
                dataSize=file.write(dataArray);
                if (dataSize>0)
                {
                    dataReadBytes+=dataSize;

                    ui->progressBar->setValue(dataReadBytes/1024);
                }
                if (dataReadBytes==fileSize)
                {
                    ui->textEdit->append("receive data and write done...");
                    file.close();
                    ui->textEdit->append("close the file");
                }

            }
        }
    }
}

void Widget::setFileInfo()
{
    ui->textEdit->append("receive file head info:");
    ui->textEdit->append("-- file name: "+fileName);
    ui->textEdit->append("-- file size: "+QString::number(fileSize));

    ui->textEdit->append("create a file ing...");

    file.setFileName(fileName);
    if (!file.open(QIODevice::WriteOnly))
    {
        ui->textEdit->append("ERROR: open file failed");
    }
    ui->textEdit->append("writing data to file...");
    ui->progressBar->setMaximum(fileSize/1024);
}


void Widget::myDisconnected()
{

}

void Widget::on_pushButton_2_clicked()
{
    listenSock->close();
    servSock->close();
}

qint64 Widget::BToLittleEndian(qint64 num)
{
    qint64 num_littleEnidan;
    num_littleEnidan=((num & 0x00000000000000FF)<<(7*8) | (num & 0x000000000000FF00)<<(5*8) |
                      (num & 0x0000000000FF0000)<<(3*8) | (num & 0x00000000FF000000)<<(1*8) |
                      (num & 0x000000FF00000000)>>(1*8) | (num & 0x0000FF0000000000)>>(3*8) |
                      (num & 0x00FF000000000000)>>(5*8) | (num & 0xFF00000000000000)>>(7*8));

    return num_littleEnidan;
}

void Widget::BToLittleEndianFromByteArray(QByteArray &arr)
{
    QByteArray arr_temp=arr;
    qint64 arrSize=arr.size();
    for (int i=0;i<arrSize;i++)
    {
        arr[i]=arr_temp[arrSize-1-i];
    }
}

.ui

在这里插入图片描述

客户端

widget.h

#ifndef WIDGET_H
#define WIDGET_H

#include <QWidget>
#include <QTcpServer>
#include <QTcpSocket>
#include <QHostAddress>
#include <QHostInfo>
#include <QFileDialog>
#include <QFile>
#include <QDebug>
#include <QString>
#include <QDataStream>
#include <QTimer>

QT_BEGIN_NAMESPACE
namespace Ui { class Widget; }
QT_END_NAMESPACE

class Widget : public QWidget
{
    Q_OBJECT

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

private slots:
    void on_pushButton_clicked();

    void on_pushButton_3_clicked();

    void myGetNewRead();

    void on_pushButton_2_clicked();

    void dataContinueSend();
    void myDisconnected();

private:
    Ui::Widget *ui;
    QTcpSocket *clientSock;
    QHostAddress servAddress;
    quint16 servPort;
    QString info;
    QFile file;
    QFileInfo fileInfo;
    QTimer *myTimer;
    qint64 fileSize;

    QByteArray dataArray;
};

#define sendBufferSize 512
#endif // WIDGET_H

widget.cpp

#include "widget.h"
#include "ui_widget.h"
#include <QProgressBar>

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

    setWindowTitle("client");
    this->resize(720,570);

    ui->lineEdit->setText("127.0.0.1");
    ui->lineEdit_2->setText("8080");

    ui->pushButton_2->setEnabled(false);
//    ui->pushButton_3->setEnabled(false);
    ui->progressBar->setValue(0);

    clientSock=new QTcpSocket(this);
    servAddress=QHostAddress(ui->lineEdit->text());
    servPort=ui->lineEdit_2->text().toUInt();

    info=QString("%1:%2").arg(ui->lineEdit->text(),ui->lineEdit_2->text());

    connect(clientSock,&QTcpSocket::readyRead,this,&Widget::myGetNewRead);
    connect(clientSock,&QTcpSocket::bytesWritten,this,&Widget::dataContinueSend);
    connect(clientSock,&QTcpSocket::disconnected,this,&Widget::myDisconnected);

    dataArray.resize(sendBufferSize);

}

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


void Widget::on_pushButton_clicked()
{
    clientSock->abort(); // 取消之前所有的连接，且抛弃所有缓冲区的内容

    clientSock->connectToHost(servAddress,servPort);
    if (!clientSock->waitForConnected(10000))
    {
        ui->textEdit->append("ERROR: connect failed...");
        return;
    }
    if (!clientSock->isValid())
    {
        ui->textEdit->append("ERROR: the socket is invalid...");
    }
    ui->textEdit->append("connect server "+info);

    ui->pushButton->setEnabled(false); // connect
    ui->pushButton_3->setEnabled(true); // openfile
}


void Widget::on_pushButton_3_clicked()
{
    QString fileName=QFileDialog::getOpenFileName(this,"打开文件","./");

    if (fileName.isEmpty())
    {
        ui->textEdit->append("ERROR: connot find file");
        return;
    }

    fileInfo=QFileInfo(fileName);
    fileSize=fileInfo.size();

    ui->lineEdit_3->setText(fileInfo.absoluteFilePath());
    ui->progressBar->setMaximum(fileSize/512);

    file.setFileName(fileInfo.absoluteFilePath());
    if (!file.open(QIODevice::ReadOnly))
    {
        ui->textEdit->append("ERROR: file open failed...");
        return ;
    }

    ui->textEdit->append("ready to send file info:");
    ui->textEdit->append("-- file name: "+fileInfo.fileName());
    ui->textEdit->append("-- file size: "+QString::number(fileSize)+" bytes");

    ui->progressBar->setMinimum(0);
    ui->progressBar->setMaximum(fileSize/1024);


    ui->pushButton_3->setEnabled(false);
    ui->pushButton_2->setEnabled(true);
}

void Widget::myGetNewRead()
{
    QByteArray readArray=clientSock->readAll();
    if (!readArray.isEmpty())
    {
        ui->textEdit->append(QString("receive from server %1:").arg(info));
        ui->textEdit->append(readArray);
    }

    if (QString(readArray)=="done")
    {
        ui->textEdit->append("server receive done...");
        ui->textEdit->append("close client...");
        clientSock->disconnectFromHost();
    }

}

void Widget::on_pushButton_2_clicked()
{
    // 以数据流的方式绑定dataHead
    QByteArray dataHead;
    QDataStream dataHeadStream(&dataHead,QIODevice::WriteOnly);
    dataHeadStream.setVersion(QDataStream::Qt_6_2);
    // 文件名大小+文件名+文件大小
    qint64 fileNameSize=(qint64)(fileInfo.fileName().toUtf8().size());
    dataHeadStream<<fileNameSize<<fileInfo.fileName().toUtf8()<<fileSize; // QString qint64
    // 当成功写入的时候 返回实际写入的字节数，并且触发bytesWrittern信号
    qDebug()<<"head size: "<<dataHead.size();
    qint64 dataHeadWrittenBytes=clientSock->write(dataHead);

    ui->textEdit->append("head info:");
    ui->textEdit->append("head data format: qint64+QString+qint64:");
    ui->textEdit->append(QString("fileNameSize+fileName+fileSize: %1+%2+%3").
                         arg(QString::number(fileNameSize),fileInfo.fileName(),QString::number(fileSize)));

    if (dataHeadWrittenBytes!=(qint64)dataHead.size())
    {
        ui->textEdit->append("ERROR: file head data written failed");
        file.close();
        return ;
    }

    dataHead.resize(0);



    // version 2
    // 将文件绑定到数据流上
//    QByteArray dataArray;
//    dataArray.resize(fileSize);
//    QDataStream dataStream(&dataArray,QIODevice::WriteOnly);

//    dataStream<<file.readAll();
}

void Widget::dataContinueSend()
{
    qint64 writtenNum=0;
    qint64 readNum=0;
    static qint64 dataWrittenBytes=0;
    static qint64 databytesToWirte=fileSize-dataWrittenBytes;

    if (databytesToWirte>0)
    {
        // 读取最小的放入,返回实际读取的
        readNum=file.read(dataArray.data(),qMin(databytesToWirte,sendBufferSize));

        if (readNum>0)
        {
            // 发送
            writtenNum=(clientSock->write(dataArray));

            dataWrittenBytes+=writtenNum; // 已经写了多少
            databytesToWirte-=writtenNum; // 还有多少没写

//            dataArray.clear();

            ui->progressBar->setValue(dataWrittenBytes/512);
        }

    }
    if (databytesToWirte<1024)
    {
        qDebug()<<"data";
    }

    if (dataWrittenBytes==fileSize)
    {
        file.close();
        ui->textEdit->append("DONE: client send data success...");
    }
}


void Widget::myDisconnected()
{
    clientSock->close();
}

.ui

在这里插入图片描述

aoaoGofei
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Qt Socket TCP通信Demo.rar
03-23
本示例着重于使用Qt库中的Socket类进行TCP（传输控制协议）通信，对于初学者来说，这是一个很好的起点。下面将详细介绍这些压缩包文件所涵盖的知识点。 首先，我们从基础开始。"1.客户端发起连接.rar"文件可能是...
TCP通信之QTcpServer和QTcpSocket，服务器和客户端通讯
houxian1103的博客
11-15 1万+
TCP传输控制协议 是一个可靠的（相对于UDP），面向流，面向连接的运输协议。 Socket 俗称“套接字”。就是对网络中不同主机上的应用进程之间进行双向通信的端点的抽象。一个套接字就是网络上进程通信的一端，提供了应用层进程利用网络协议交换数据的机制。从所处的地位来讲，套接字上联应用进程，下联网络协议栈，是应用程序通过网络协议进行通信的接口，是应用程序与网络协议根进行交互的接口。 套接字Socket=（IP地址：端口号） QTcpSocket传输的过程是连续的（对于网络的要求是比较高的，稳定）。TCP编程一
Qt套接字怎么传输文件
hw5230的博客
04-24 298
在服务器端接收文件内容，并保存到指定位置。打开本地需要传输的文件，并读取到内存中。将文件内容通过QT套接字发送给服务器端。建立TCP连接，创建QT套接字。关闭QT套接字，断开TCP连接。
【QT学习】13.使用TCP实现文件传输
最新发布
m0_61659911的博客
04-30 1121
【代码】【QT学习】13.使用TCP实现文件传输。
网络通信/QTcpSocket/实现一个可在子线程中发送和接收数据的TCP客户端
river.qu
06-11 7018
基于QTcpSocket类实现一种可在子线程中收发数据的TCP客户端程序。验证了，如果一个Tcp对象被移动到子线程X中，那么其readyRead、connected、disconnected信号等都将从子线程X中发出。
QT下TCP协议实现数据网络传输
hsy12342611的专栏
11-27 3672
QT
QT_stuy.rar_QT学习资料
09-21
4. **QT网络编程**：“QT TCP下的socket编程.txt”涵盖了QT如何利用QSslSocket、QTcpSocket等类进行TCP/IP通信，可能涉及服务器和客户端的建立、数据传输以及错误处理等内容。 5. **键盘驱动设定**：“QT键盘驱动...
C++ 实现的FreeEIM-Debug局域网聊天工具
09-05
1. **网络编程**：使用套接字（Socket）编程实现网络通信，处理TCP或UDP协议，确保数据的可靠传输。 2. **多线程**：利用C++的线程库（如std::thread），实现并发处理，提高程序的响应速度和用户体验。 3. **事件...
AdvancedCLanguageSourceProgram.zip_文件操作_C/C++_
08-12
网络编程还需要理解TCP/IP协议栈以及面向连接的TCP和无连接的UDP协议。 菜单和窗口功能通常是图形用户界面（GUI）编程的一部分，C语言本身并不直接支持GUI，但可以借助第三方库如GTK+、Qt或Win32 API来实现。菜单...
ARM初学者学习ARM的步骤-基于linux系统的学习步骤
11-03
- **配置TFTP/NFS服务**：掌握远程文件传输和网络文件系统配置。 - **Bootloader和内核**：下载并编译U-boot和Linux内核。 - **应用软件开发流程**：熟悉嵌入式Linux应用软件的开发、编译、调试流程。 #### 五、...
QT通过TCP协议传输文件
weixin_43473965的博客
06-17 2572
常用的网络协议分为TCP和UDP两种，两种方式各有优缺点，其中TCP的主要特点是可靠，但是速度较慢（不丢包）；而UDP则是不可靠传输，但速度快（可能丢包）。今天主要介绍的就是通过QT框架和TCP协议实现简单的文件传输。
QT使用Socket通信
weixin_43654097的博客
03-02 3891
QT中TCP/UDP/Socket/组播/广播
【QT】TCP通信（QTcpServer 和 QTcpSocket）
瞌睡的博客
02-13 4500
TCP是一种被大多数Internet网络协议（如HTTP）用于数据传输的低级网络协议，它是可靠的、面向流、面向连接的传输协议，特别适合于连续数据传输。TCP通信必须先建立TCP连接，分为服务器端和客户端。Qt提供QTcpServer类和QTcpSocket类用于建立TCP通信。服务器端必须使用QTcpServer用于端口监听，建立服务器；QTcpSocket用于建立连接后使用套接字进行通信。
QT——QByteArray及QBuffer
热门推荐
见证自己的成长之路~
05-26 3万+
类介绍： QByteArray类提供了一个字节数组，通常QByteArray被用来存储了一般的字节（包括'\0'）一级传统的8位以'\0'结尾的字符串。由于QByteArray封装的功能很多，使用起来比char*要方便的多，而就其内部实现来讲，它会保证所有的数据以'\0'结尾，使用隐式数据共享（copy-on-write）来减少内存消耗以及不必要的数据拷贝。            除了QB
Qt模块化笔记之network——第二个TCP程序，传输图片文件的实现(2)
qt爱好者
03-03 5871
本节你将了解如何传输一个文件，以图片文件示例。 在以前socket的write函数只，我们都只是写入少量的文字，大小也许还不到一K，它的写入时间极短，接收时间也极短，很少需要考虑是否保证它完整地传输到另一端。 但文件不同，文件的传输需要保证它的每一部分都传送到另一端，另一端才能将它还原。 比如我们的浏览器从网络下载文件的时候，它在下载之前就获得了需要下载的文件信息，如文件名，文件大小，进而在
Qt-socket网络 - tcp文件传输
L_fengzifei的博客
03-14 392
Qt-socket网络 - tcp文件传输
使用QSocket实现的文件传输软件（聊天）
机器人梦想家 Bing
03-02 1572
文章目录使用QSocket实现的文件传输软件（聊天）引言代码说明QtChatServerQtChatClientSocketReceverCMDSocketSenderCMD 使用QSocket实现的文件传输软件（聊天） 引言 好一段时间没有写博客了，新的一年才刚刚来到反倒有些放纵自己，但是还是要加足劲努力加油！ 这篇文章是将春节前写的一个简单的文件传输软件记录下来，代码也已经上传到github里。 代码说明 这个项目由四个工程组成分别是： QtChatClient UI交互的客户端 QtChatServ
Qt使用QTcpSocket及QTcpServer传输文件
weixin_41377572的博客
03-09 654
Tcp传输文件
Qt中的缓冲区QBuffer
木子皿--啥都不会的菜鸟
03-12 6415
文章目录1 Qt中的缓冲区QBuffer 1 Qt中的缓冲区QBuffer Qt中缓冲区的概念： 缓冲区的本质为一段连续的存储空间。 QBuffer是Qt中缓冲区相关的类。 在Qt中可以将缓冲区看作一种特殊的IO设备。 文件流辅助类可以直接用于操作缓冲区。 QBuffer缓冲区的使用方式： QBuffer缓冲区的使用场合： 在线程间进行不同类型的数据传递。 缓存外部设备中的数据返回。 数据...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值