日常知识点之遇到问题结构体按位构造协议时和期望不一致，研究记录一下

最新推荐文章于 2024-09-07 15:00:52 发布

yun6853992

最新推荐文章于 2024-09-07 15:00:52 发布

阅读量390

点赞数 3

分类专栏：常用知识点文章标签： linux

本文链接：https://blog.csdn.net/yun6853992/article/details/141019331

版权

常用知识点专栏收录该内容

31 篇文章 4 订阅

订阅专栏

遇到一个问题，在做业务的时候，涉及到协议相关，按位进行设计，用结构体来模拟协议时，发现内存存储和实际目的不一致，知道是大小端以及计算机底层存储逻辑相关，所以研究了一下。

1：简单问题描述。

如下结构，是按照用户协议解析出来的结构：

按照数据协议，总共6个字节，期望按占位3，1，1，1，5，5 ，2，20，10进行解析，这里期望的是内存中存储的值是按照结构进行存储和展示的。

//我本来构造这样对应的结构。
#pragma pack(1)
typedef struct _trans_header_t
{
    unsigned short version:3;  
    unsigned short type:1;     
    unsigned short vice_type:1;  
    unsigned short apid_tid:1; 
    unsigned short apid_pid:5; 
    unsigned short apid_pcat:5; 

    unsigned int group_type:2; 
    unsigned int trans_num:20; 
    unsigned int trans_user_data_len:10;
}TRANS_HEADER_T;
#pragma pack()

如上，对应期望的协议，我定义了对应的结构，但是赋值时发现对不上。（这里肯定是结构体位和对应大小端问题导致。）

2：分析一下这里位和大小端的存储。

结构体设置按字节对齐（默认或者自己设置，小端模式，按位处理实际上是从低位开始）

int main(int argc, char *argv[])
{
    TRANS_HEADER_T header;
    header.version = 1;
    header.type = 0;
    header.vice_type = 1;
    header.apid_tid = 0;
    header.apid_pid = 3;
    header.apid_pcat = 3;

    header.group_type=3;
    header.trans_num = 7;
    header.trans_user_data_len = 1;
/********************  
1101 0001       11 0 1 0 001 
0001 1000		00011  000
0001 1111  		000111 11
0000 0000		00000000
0100 0000 		01 000000 
0000 0000		00000000
*********************/
	for(unsigned int i=0; i<sizeof(header); i++)
    {
        int num = *((unsigned char *)&header +i);
        qDebug() <<num<<"===>"<< QString::number(num, 2) ;
    }
    
    unsigned short *UTest = (unsigned short *)&header;
    qDebug()<<"data = "<<(*UTest); //6353     0001 1000 1101 0001

    unsigned int *UTest1 = (unsigned int *)((unsigned char *)&header +2);
    qDebug()<<"data = "<<(*UTest1); //4194335   0000 0000 0100 0000 0000 0000 0001 1111
    
    return 0;
}
//分析一下，因为按1Byte进行对齐，所以每次以1Byte进行处理，从低位开始按位赋值，当1byte不够用时，就取下一个byte，这是低位进行赋值。
//按每1byte，按照结构体定义的结构，依次赋值。
//然后大小端的问题，实际上是转成对应的unsigned short和unsigned int时取值时生效的。

3：疑问以及总结

疑问：本想按照定义的结构给结构体赋值，发现赋值后期望结果和预期不一致。

总结：其实核心还是按位处理，按位处理时是从低位往高位写。

处理：

方案1：我直接抛弃这种方案，采用字节|的方式。

(这里注意数值的写入是以内存中存的值为准，按值进行设置的数据，需要按内存进行大小端处理)

	//short +unsigned int
    unsigned short version_apid = 0;
    unsigned int flag_and_len = 0;

    // 000 1 0 010 001 9+i 前6位固定   0001 00 激光载荷10001 文件 9+i
    if(!m_is_reTrans)
    {
        version_apid |= 0x1220; // 0001 0010
    }else
    {
        version_apid |= 0x1620; // 0001 0110
    }

    version_apid |= 9+i;

    //分组标识和对应的数据长度
    flag_and_len |= 0xC0000000;
    flag_and_len |= arr.size()-1;

    dst_arr.resize(8+arr.size());
    dst_arr.fill(0);

    version_apid = short_host_to_network(version_apid);
    flag_and_len = int_host_to_network(flag_and_len);

bool IsBigEndian()
{
    short a = 0x1234;
    char b = *(char*)&a;
    if (0x12 == b) //高位存储在低地址处  是大端
    {
        return true;
    }
    return false; //否则   高位存储在高地址位  小端模式
}


unsigned int int_host_to_network(unsigned int number)
{
    bool flag = IsBigEndian();
    if (flag) //大端模式  不用处理
    {
        return number;
    }

    unsigned int data = number;
    unsigned char* abyte0 = (unsigned char*)&data;
    // 小端模式
    if (!flag) //如果电脑是小端模式  需要处理成大端模式
    {
        abyte0[0] = (unsigned char)((0xff000000 & number) >> 24);
        abyte0[1] = (unsigned char)((0x00ff0000 & number) >> 16);
        abyte0[2] = (unsigned char)((0x0000ff00 & number) >> 8);
        abyte0[3] = (unsigned char)(0x000000ff & number);
    }
    return data;
}

unsigned short short_host_to_network(unsigned short number)
{
    bool flag = IsBigEndian();
    if (flag) //大端模式  不用处理
    {
        return number;
    }
    unsigned short data = number;
    unsigned char* abyte0 = (unsigned char*)&data;
    // 小端模式 //需要进行处理
    if (!flag)
    {
        abyte0[0] = (unsigned char)((0xff00 & number) >> 8);
        abyte0[1] = (unsigned char)(0x00ff & number);
    }
    return data;
}

方案二：

按照结构体的思路，对结构体进行处理使其符合。（一般协议设计以8位为准（这种容易处理，结构体定义时和协议反转就好），这里比较复杂，用到16位，32位，思考测试有没有可用方案。）

如果是大端，理论上按协议定义结构体是没问题的，从高位往低位，位依次存储（未验证）

如果是小端，按位存储，实际上是从低位往高位，比如1byte从后往前写。

===》如果结构体协议位刚好凑够8位，则对结构体进行反转即可。

===》如果类似如下的结构，大端模式理论直接赋值可以，小端模式复杂化，没想到对应方案。

//如果位拼接刚好满足1byte 8位，则以1byte进行结构体反转能适配到协议吧。
//这里位刚好凑到16位，32位，需要根据大小端和结构体做适配吧。      
//如果是大端，理论上按协议定义结构体是没问题的，从高位往低位，位依次存储（未验证）
//如果是小端，需要自己处理，这里能想到的是，对结构体进行适配，如下，赋值后进行大小端转换是否可行？    
//     按位存储是从低位往高位存储，如下对按照协议，这样赋值，测试后发现  也是不合理的 
#pragma pack(1)
typedef struct _trans_header_t
{
    unsigned short apid_pcat:5; //源包的名称
	unsigned short apid_pid:5; //产生源包的设备 
	unsigned short apid_tid:1; //重传标志 默认为0
	unsigned short vice_type:1;  //副导头   0b
	unsigned short type:1;     //1B   遥控源包
	unsigned short version:3;  //000B
	
	unsigned int trans_user_data_len:10;
	unsigned int trans_num:20; //对相同apid进行计数 初始值为0    如果源包文件小于875字节   填0
    unsigned int group_type:2; //分组标识  固定11b
}TRANS_HEADER_T;
#pragma pack()