最全Qt---处理粘包_qt数据粘包，震撼发布

于 2024-05-15 05:12:17 发布
阅读量461 收藏 3
点赞数 4
分类专栏： 程序员 文章标签： 物联网 嵌入式硬件 学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2401_85015426/article/details/138884804
版权

收集整理了一份《2024年最新物联网嵌入式全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升的朋友。
img
img

如果你需要这些资料，可以戳这里获取

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人

都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！

这里写图片描述

粘包处理后

服务器端

#pragma pack(push, 1) //按照1字节对齐
typedef struct
{
    int len;          //包头，包体长度
    char data[1024];  //包体
}NetPacket;
#pragma pack(pop)

//出现一个新连接时调用
void myTcpServer::incomingConnection(int socketDescriptor)
{
    clientConnection = new QTcpSocket;
    clientConnection->setSocketDescriptor(socketDescriptor);

    char *d1 = "data1";
    char *d2 = "data2";
    char *d3 = "data3";

    NetPacket p1, p2, p3;

    p1.len = sizeof("data1");     //封装第一个数据包
    memcpy(p1.data, d1, p1.len);

    p2.len = sizeof("data2");
    memcpy(p2.data, d2, p2.len);

    p3.len = sizeof("data3");
    memcpy(p3.data, d3, p3.len);

    clientConnection->write((char *)&p1, sizeof(int) + p1.len);  //发送数据包
    clientConnection->write((char *)&p2, sizeof(int) + p2.len);
clientConnection->write((char *)&p3, sizeof(int) + p3.len);
}

客户端

void myTcpClient::slotRead()
{
    while(tcpSocket->bytesAvailable()>0)
    {

        int len;
        char buf[1024];    //接收数据的缓冲区
        char tmpBuf[1024]; //存放包体
        int nOffset = 0;   //偏移

        int n = tcpSocket->bytesAvailable(); //接收到的字节数
        tcpSocket->read(buf, n);             

        memcpy(&len, buf, sizeof(int));    //包头：包体长度
        nOffset += sizeof(int);  
        memcpy(tmpBuf, buf+nOffset, len);  //包体
        nOffset += len;
        printf("%s\n", tmpBuf);            //打印包体

        memcpy(&len, buf, sizeof(int));
        nOffset += sizeof(int);
        memcpy(tmpBuf, buf+nOffset, len);
        nOffset += len;
        printf("%s\n", tmpBuf);

        memcpy(&len, buf, sizeof(int));
        nOffset += sizeof(int);
        memcpy(tmpBuf, buf+nOffset, len);
        nOffset += len;
        printf("%s\n", tmpBuf);

    }
}

运行结果：
这里写图片描述

完整版

服务器端和客户端共有的文件

databuffer.h

#ifndef NETDATABUFFER_H
#define NETDATABUFFER_H

#define BUFFER_SIZE  1024  //初始缓冲区大小

class DataBuffer
{
public:
    char *m_pBuffer;    //缓冲区
    int m_nBufferSize;  //缓冲区大小
    int m_nOffset;      //缓冲区中当前数据大小

    int getDataLen();         //获得缓冲区中数据大小
    bool reBufferSize(int nLen); //调整缓冲区大小
    bool addMsg(char *pBuf, int nLen);  //添加消息到缓冲区
    void reset();          //缓冲区复位
    void poll(int nLen);   //移除缓冲区首部的第一个数据包

 public:
    DataBuffer();
    ~DataBuffer();
};

#endif // NETDATABUFFER_H

databuffer.cpp

#include "databuffer.h"
#include "string.h"
#include <QException>

//构造
DataBuffer::DataBuffer()
{
    m_nBufferSize = BUFFER_SIZE;  //缓冲区大小
    m_nOffset = 0;      //缓冲区当前现有数据大小
    m_pBuffer = new char[m_nBufferSize];      //分配缓冲区
    memset(m_pBuffer, 0, sizeof(m_pBuffer));  //清空缓冲区
}

//析构
DataBuffer::~DataBuffer()
{
    delete [] m_pBuffer;  //释放缓冲区
    m_pBuffer = NULL;
    m_nBufferSize = 0;
    m_nOffset = 0;
}

//获得缓冲区中数据大小
int DataBuffer::getDataLen()
{
    return m_nOffset;
}

//重置缓冲区大小
bool DataBuffer::reBufferSize(int nLen)
{
    char *oBuffer = m_pBuffer;  //保存原缓冲区地址
    try
    {
        nLen = nLen < 64 ? 64: nLen;  //保证最小大小
        while(m_nBufferSize < nLen)
        {
            m_nBufferSize *= 2;
        }
        m_pBuffer = new char[m_nBufferSize]; //分配新缓冲区
        memset(m_pBuffer, 0, sizeof(m_pBuffer));
        memcpy(m_pBuffer, oBuffer, m_nOffset); //将原缓冲区中的内容拷贝到新缓冲区
        delete []oBuffer;  //释放原缓冲区
    }
    catch(QException e)
    {
        return false;
    }
    return true;
}

//向缓冲区中添加消息
/*
 * pBuf，要添加的数据
 * nLen，数据长度
 * 成功返回true，失败返回false
 */
bool DataBuffer::addMsg(char *pBuf, int nLen)
{
    try
    {
        if(m_nOffset + nLen > m_nBufferSize)        //如果缓冲过小，重新调整其大小
            reBufferSize(m_nOffset + nLen);
        memcpy(m_pBuffer + m_nOffset, pBuf, nLen); //将新数据拷贝到缓冲区尾
        m_nOffset += nLen;  //修改数据偏移
    }
    catch(QException e)
    {
        return false;
    }
    return true;
}

//缓冲区复位
void DataBuffer::reset()
{
    if(m_nOffset > 0)
    {
        memset(m_pBuffer, 0, sizeof(m_pBuffer));
        m_nOffset = 0;
    }
}

//移除缓冲区首部第一个数据包
//nLen：一个数据包的大小
void DataBuffer::poll(int nLen)
{
    if(m_nOffset == 0 || m_pBuffer == NULL)
        return;

   if(m_nOffset >= nLen)
   {
        memcpy(m_pBuffer, m_pBuffer + nLen, m_nOffset - nLen);
        m_nOffset -= nLen;
   }
}

netcom.h

#ifndef NETTEMPLATE_H
#define NETTEMPLATE_H

#include <QTcpSocket>
#include <QDebug>
#include "databuffer.h"

#pragma pack(push, 1) //采用1字节对齐方式

//包头
typedef struct
{
    int nLen;  //包体长度
}PacketHead;

//封包对象：包头 + 包体
typedef struct
{
    PacketHead head;  //包头
    char *body;       //包体
}Packet;

#pragma pack(pop)

class NetComTemplate
{
 public:
    QTcpSocket *m_tcpSocket;  //通信套接字
    DataBuffer m_Buffer;      //套接字关联的缓冲区

    void packData(char *data, int nLen);   //封包，发送
    void unpackData(char *data, int nLen); //将接收到的数据放在缓冲区后，解包
    virtual void recv(char *data);         //每解完一包之后的处理，留给继承的类去实现

    NetComTemplate();
    ~NetComTemplate();
};

#endif // NETTEMPLATE_H

netcom.cpp

#include "netcom.h"

NetComTemplate::NetComTemplate()
{

}

NetComTemplate::~NetComTemplate()
{

}

//封包，发送
//data: 要发送的数据
//nLen: 要发送数据的长度
void NetComTemplate::packData(char *data, int nLen)
{
    Packet p;
    int headLen = sizeof(PacketHead);         //包头大小
    p.head.nLen = nLen;                       //包体大小
    char *buf = new char[headLen + nLen];
    memcpy(buf, &p.head, headLen);            //包头
    memcpy(buf + headLen, data, nLen);        //包体
    if(m_tcpSocket != NULL)
        m_tcpSocket->write(buf, headLen + nLen);  //发包
    else
        qDebug() << "socket 未建立！";
}

//解包
//data: 要发送的数据
//nLen: 要发送数据的长度
void NetComTemplate::unpackData(char *data, int nLen)
{
    m_Buffer.addMsg(data, nLen);              //添加数据到缓冲区
    int totalLen = m_Buffer.getDataLen();  //缓冲区中数据大小
    int headLen = sizeof(PacketHead);         //包头大小
    while(totalLen > 0)
    {
        //不够包头，不处理
        if(totalLen < headLen)
        {
            break;
        }

        Packet pack;                      //接收到的包
        memcpy(&pack.head, m_Buffer.m_pBuffer, headLen);   //包头
        int bodyLen = pack.head.nLen;     //包体大小
        int packLen = headLen + bodyLen;  //一包数据大小
        if(totalLen < packLen)            //不够一包数据，等够了再解析
        {
            break;
        }

        //数据足够多
        pack.body = new char[bodyLen];
        memcpy(pack.body, m_Buffer.m_pBuffer + headLen, bodyLen);  //包体
        recv(pack.body);         //处理得到的包体

        m_Buffer.poll(packLen);  //移除缓冲区中第一个数据包
        totalLen -= (packLen);
    }
}

//留给继承的类去实现
//buf: 解包后得到的包体
void NetComTemplate::recv(char *data)
{

}

服务器端

tcpserver.h

#ifndef TCPSERVER_H
#define TCPSERVER_H

#include <QTcpServer>
#include <QTcpSocket>
#include <QObject>
#include "netcom.h"

class myTcpServer : public QTcpServer, public NetComTemplate
{
    Q_OBJECT

public:
    myTcpServer(QObject *parent, int port);
    ~myTcpServer();

protected:
    void incomingConnection(int socketDescriptor);
};

#endif // TCPSERVER_H

tcpserver.cpp

#include "tcpserver.h"
#include <QDataStream>
#include <stdlib.h>

myTcpServer::myTcpServer(QObject *parent, int port): QTcpServer(parent)
{
    listen(QHostAddress::Any, port);
}

myTcpServer::~myTcpServer()
{
    
}

//出现一个新连接时调用
void myTcpServer::incomingConnection(int socketDescriptor)
{
    m_tcpSocket = new QTcpSocket;
    m_tcpSocket->setSocketDescriptor(socketDescriptor);

    char *d1 = "data1";
    char *d2 = "data2";
    char *d3 = "data3";

    packData(d1, sizeof("data1"));   //封包，发送
    packData(d2, sizeof("data2"));
    packData(d3, sizeof("data3"));
}

客户端

tcpclient.h

#ifndef MYTCPCLIENT_H
#define MYTCPCLIENT_H

#include <QTcpSocket>
#include <QtNetwork>
#include "netcom.h"

class myTcpClient : public QObject, public NetComTemplate
{
    Q_OBJECT

public:
myTcpClient(QObject *parent = 0);
    ~myTcpClient();

    void recv(char *data);           //每解完一包之后的处理

public slots:
    void slotRead();
};

#endif // MYTCPCLIENT_H

tcpclient.cpp

#include "tcpclient.h"

myTcpClient::myTcpClient(QObject *parent) : QObject(parent)
{
    m_tcpSocket = new QTcpSocket;
    connect(m_tcpSocket, SIGNAL(readyRead()), this, SLOT(slotRead()));
    m_tcpSocket->connectToHost(QHostAddress("127.0.0.1"), 8180);
}

myTcpClient::~myTcpClient()
{
 
}

void myTcpClient::slotRead()
{
    while(m_tcpSocket->bytesAvailable()>0)
    {
        int n = m_tcpSocket->bytesAvailable();  //接收到的字节数
        char *buf = new char[n];
        m_tcpSocket->read(buf, n);   //读取数据
        unpackData(buf, n);   //解包
	delete []buf;
    }
}

//解包之后的处理
void myTcpClient::recv(char *data)
{
    printf("%s\n", data);
}

完善版（使用环形缓冲区）

相对于“完整版”所改动的地方

img
img

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上物联网嵌入式知识点，真正体系化！

由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、电子书籍、讲解视频，并且后续会持续更新

如果你需要这些资料，可以戳这里获取

et->read(buf, n); //读取数据
unpackData(buf, n); //解包
delete []buf;
}
}

//解包之后的处理
void myTcpClient::recv(char *data)
{
printf(“%s\n”, data);
}


### 完善版（使用环形缓冲区）


相对于“完整版”所改动的地方



[外链图片转存中...(img-mhsaVU8G-1715721114036)]
[外链图片转存中...(img-DLwxX97A-1715721114037)]

**既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上物联网嵌入式知识点，真正体系化！**

**由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、电子书籍、讲解视频，并且后续会持续更新**

**[如果你需要这些资料，可以戳这里获取](https://bbs.csdn.net/topics/618679757)**
2401_85015426
关注
  • 4
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【QT】自定义协议解决TCP粘包和拆包问题
08-11
本demo模拟了TCP通信中发送端和接收端的行为，并利用序列化和反序列化的思想，自定义协议来解决TCP的粘包和拆包问题。
tcp-client-1012.rar tcp的qt客户端
01-04
tcp协议里面，除了心跳检测是关于长连接操作的处理，这个在前一篇已经提到过了，这一篇将会对tcp本身的一个问题，进行处理：那就是做网络通信大概率会遇到的问题，粘包、拆包问题，碰到这类问题对于新手来说都是比较...
【C/C++ 串口编程 】深入探讨C/C++与Qt串口编程中的粘包现象及其解决策略
探索C++编程的奥秘，分享深入的技术见解和实践，旨在激发读者创造力与解决问题的思维。
08-15 1217
在嵌入式领域，我们经常会遇到各种各样的问题，其中之一就是串口编程中的“粘包”现象。这个问题可能看起来很小，但如果不处理，它可能会导致数据传输的不稳定和不可靠。为了更好地理解这个问题，我们需要从人的心理角度来看待它。
Qt---处理粘包
新博客：https://aping-dev.com/
07-23 6292
参看： http://blog.csdn.net/pi9nc/article/details/17165171 http://www.aiuxian.com/article/p-1732805.html#t0 http://www.cnblogs.com/alon/archive/2009/04/16/1437599.html http://www.aiuxian.com/article/p
Qt中对TCP粘包的处理
qq_40170041的博客
03-29 970
比如此次接收到的长度为100，那么就向后读取100个字节的数据，就是此次的一个包，哪怕此时缓冲区有1000个字节数据，只读这100个字节就能获取一个完整的包，剩余的900个字节就需要下一次去处理，下次处理的时候还是先读包头，读出数据包的一个长度，然后根据这个长度去读取相应的数据，这样一次一次读取就可以一点一点把数据拆分出来了。是的，这个时候数据已经到达客户端了，只不过被保存在客户端的缓存中了（内核缓冲区），客户端只有在read的时候才能读出数据。数据应该在内存，怎么会在网线里面，又没有内存。
QT 处理TCP粘包问题
路过的熊的博客
02-27 3005
处理粘包的方式是在消息头部加上消息总长度。 采用该格式： 消息总长度len（4字节）+命令字commandId（4字节）+消息msg。 思路是用一个buffer，每次有消息就读完，然后判断buffer长度，收到四字节长度len后，根据len收消息，当buffer.size()>=len,这时已经收到一个完整的包就可以处理了，处理完后就将buffer前len个字节删除掉，如此反复。 //socket有数据到来就读 connect(m_socket, SIGNAL(readyRead()), this,
Qt网络编程——处理TCP粘包
最新发布
bmseven的博客
03-07 733
TCP 是面向连接的、安全的流式传输协议。所谓流式协议，即协议的内容是像流水一样的字节流，内容与内容之间没有明确的分界标志，因此会产生粘包现象
QT/C++ TCP多线程客户端（收发线程分离，自动粘包处理，自动数据包成型）
09-03
QT/C++ TCP多线程客户端的设计是为了解决在高并发场景下可靠地收发数据的问题。TCP（传输控制协议）是一种面向连接的、可靠的、基于字节流的传输层通信协议，它确保了数据的顺序传输和错误检测。然而，当面对大量...
TCP_QTTCP_tcp_C++_QT_qttcpsend_
09-30
在QT中，我们可以使用QNetworkAccessManager和QTcpSocket等类来处理TCP连接和数据交换。 TCP是一种面向连接的、可靠的传输协议，它确保了数据包在传输过程中的顺序和完整性。在C++中使用QT实现TCP通信，首先要创建...
Socket编程TCP粘包Demo.zip
05-22
通过运行这个Demo，我们可以观察到如何在实际编码中处理粘包问题，以及如何利用上述策略来改善数据传输的准确性和效率。 这个Demo不仅有助于理解TCP粘包的原理，还能够提升我们在实际开发中的问题解决能力。在学习...
Qt TCP 分包粘包的解决方法
读书笔记
07-04 3446
Qt 处理粘包半包的demo
Qt的TCP粘包分包
风斜夜的博客
04-30 3378
粘包只可能出现在流传输中，TCP是基于流传输的，而UDP是不会出现粘包，因为UDP是基于报文的，也就是说UDP发送端调用几次write，接收端必须调用相同次数的read读完，每次最多只能读取一个报文，报文与报文是不会合并的，如果缓冲区小于报文长度，则多出来的部分会被丢掉。TCP不同了，它会合并消息，并且以不确定方式合并，这样就需要我们去粘包处理了，TCP造成粘包可能是发送端也...
C++ Qt TCP协议，处理粘包、拆包问题，加上数据头来处理
十年以上编程经验的干货分享
11-20 2337
tcp协议里面，除了心跳检测是关于长连接操作的处理，这个在前一篇已经提到过了，这一篇将会对tcp本身的一个问题，进行处理：那就是做网络通信大概率会遇到的问题，粘包、拆包问题，碰到这类问题对于新手来说都是比较棘手的，需要好好处理一下。
QTcpSocket 及 TCP粘包分析
Code搬运工
01-07 7011
一、长连接与短连接1、长连接 Client方与Server方先建立通讯连接，连接建立后不断开， 然后再进行报文发送和接收。2、短连接 Client方与Server每进行一次报文收发交易时才进行通讯连接，交易完毕后立即断开连接。此种方式常用于一点对多点通讯，比如多个Client连接一个Server。二、什么时候需要考虑粘包问题?1、如果利用tcp每次发送数据，就与对方建立连接，然后双方
Qt开发-TCP处理粘包
hw5230的博客
05-10 835
的次数不固定，报文间会以随机的方式合并，这就需要在接收时处理粘包了。通过上面的分析，我们可以发现，粘包只可能出现在流式传输中。这里我将客户端接收小车数据的防粘包的处理方法代码示例出来，主要是定义了一个缓冲区，将从。这里我针对项目中遇到的问题主要是接收数据时存在粘包问题，进行分析。，每次读取一个报文，报文间不合并，多余缓冲区的报文会丢弃。中读取的数据放入缓冲区，再从缓冲区中按固定结构去解析数据。对于后三种情况，我们都是要进行粘包处理的。通过上面的代码，我们可以看到，对于。是基于报文传输的，发送几次。
QT tcp粘包问题
Johnable的博客
09-11 698
QT tcp粘包问题 2016年12月27日 23:50:06月下独奏阅读数 1282更多 分类专栏：QT 版权声明：本文为博主原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接和本声明。 本文链接：https://blog.csdn.net/d7185540/article/details/53900603 当两次发送时间过短，两次发送的数据包将会合成一个...
QT TCP粘包问题解决方案
weixin_49107487的博客
08-02 1030
QT
关于QT中QTcpSocket接收数据的粘包问题的解决方案
yangzijiangtou
08-16 6456
最近做项目时，用QTcpSocket做客户端去接收数据，发现有时数据量大的时候，只能接收到部分数据，查了一些资料发现，这个就是Tcp的粘包问题，因为Tcp发送的数据是以流的形式传送的，就像水龙头放水一样，中间会也有断开的地方，所以我们接水的时候不能只接一次就结束了，因为后面还有数据在传送过来。所以我们要清楚何时才能结束接收过程？ 可以通过自定义数据协议的方式，比如说接收到定义好的标识数据就代表该次...
qt 处理udp数据粘包的例子
05-21
// 读取所有待处理数据报 while (m_udpSocket->hasPendingDatagrams()) { // 从套接字中读取数据报 m_recvBuffer.resize(m_udpSocket->pendingDatagramSize()); m_udpSocket->readDatagram(m_recvBuffer.data()...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值