字节对齐（C++，C#）

C#字节对齐示例

结构体定义

[StructLayoutAttribute(LayoutKind.Sequential, CharSet = CharSet.Ansi, Pack = 1)]，这是C#引用非托管的C/C++的DLL的一种定义定义结构体的方式，主要是为了内存中排序，LayoutKind有两个属性Sequential和Explicit，Sequential表示顺序存储，结构体内数据在内存中都是顺序存放的，CharSet=CharSet.Ansi表示编码方式。这都是为了使用非托管的指针准备的，这两点大家记住就可以。

Pack = 1 这个特性，它代表了结构体的字节对齐方式，在实际开发中，C++开发环境开始默认是2字节对齐方式 ，拿上面报文包头结构体为例，char类型在虽然在内存中至占用一个字节，但在结构体转为字节数组时，系统会自动补齐两个字节，所以如果C#这面定义为Pack=1,C++默认为2字节对齐的话，双方结构体会出现长度不一致的情况，相互转换时必然会发生错位，所以需要大家都默认1字节对齐的方式，C#定义Pack=1,C++ 添加 #pragma pack 1，保证结构体中字节对齐方式一致。

数组的定义，结构体中每个成员的长度都是需要明确的，因为内存需要根据这个分配空间，而C#结构体中数组是无法进行初始化的，这里我们需要在成员声明时进行定义；

[StructLayout(LayoutKind.Sequential, CharSet=CharSet.Ansi,Pack = 1)]
public struct PackHeader
{
    public ushort packFlag;
    public ushort packlen;
    public ushort version;
    public ushort index;
}

[StructLayout(LayoutKind.Sequential, CharSet=CharSet.Ansi, Pack = 1)]
public struct SendHeader
{
    public byte packFlag;
    [MarshalAs(UnmanagedType.ByValArray, SizeConst = 3)]
    public byte[] space; //  数组，指定长度
    public ushort beflen;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

byte[] 转结构体

using System.Runtime.InteropServices;  // 引入命名空间
/// 

/// 解析数据结构体
/// 
/// 
/// 
/// 
/// 
public static object BytesToStruct(byte[] buf, int len, Type type)
{
    object rtn;
    try
    {
        IntPtr buffer = Marshal.AllocHGlobal(len);
        Marshal.Copy(buf, 0, buffer, len);
        rtn = Marshal.PtrToStructure(buffer, type);
        Marshal.FreeHGlobal(buffer);
        return rtn;
    }
    catch (Exception)
    {
        return null;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

结构体转byte[]

 

/// 结构体转byte数组
/// 
/// 要转换的结构体
/// 转换后的byte数组
public static byte[] StructToBytes(object structObj)
{
    //得到结构体的大小
    int size = Marshal.SizeOf(structObj);
    //创建byte数组
    byte[] bytes = new byte[size];
    //分配结构体大小的内存空间
    IntPtr structPtr = Marshal.AllocHGlobal(size);
    //将结构体拷到分配好的内存空间
    Marshal.StructureToPtr(structObj, structPtr, false);
    //从内存空间拷到byte数组
    Marshal.Copy(structPtr, bytes, 0, size);
    //释放内存空间
    Marshal.FreeHGlobal(structPtr);
    //返回byte数组
    return bytes;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

C++ 字节对齐

字节对齐的好处：加快变量在内存的存取速度。

VS, VC等编译器默认是#pragma pack(8)常；注意gcc默认是#pragma pack(4)，并且gcc只支持1,2,4对齐。

结构体的每个成员相对于结构体的首地址的偏移量，都是基本成员大小的整数倍。比如

struct{
    int a;     //4  首地址&a
    char b;    //1     第二个成员&b相对于第一个成员&a是整数倍
    double c;    //8
}
1
2
3
4
5

常用对齐pragma pack(1)方式与数据解析

字节对齐常用的是数据解析与数据封装；pragma pack(1)是最常用的对齐方式之一。

#pragma once
#pragma pack(1)
typedef struct{
    unsigned short headerFlag;
    unsigned short len;
    unsigned char cmd;
} DataHeader,*PDataHeader;

typedef struct{
    unsigned short val;
} DataHeart,*PDataHeart;

typedef struct {
    unsigned char cmdNo;
    unsigned short timeSpan;
    unsigned char spaces[6];
}DataCmd, *PDataCmd;
#pragam pack()

struct DataProtocUtils{
    // 解包示例
    bool ParseData(const char * buf,int len,int & cmdNo){
        PDataHeader pheader;
        PDataCmd = cmd;
        pheader = (PDataHeader)buf;
        if(pheader->cmd == 0x01){
            cmd = (PDataCmd)(buf+sizeof(DataHeader));
            cmdNo = cmd->cmdNo;
            return true;
        }
        return false;
    }
 	// 封包示例
    bool PackHeartToHost(unsigned short state,char * buf,int & len){
        DataHeader header;
        header.headerFlag = 0x3A3A;
        header.cmd = 0x32;
        header.len = 1+sizeof(DataHeart); // len 不包括headerFlag、len、tail的长度；
        								  // 协议定义时一定要说明，否则会造成歧义
        DataHeart heart;
        heart.val  = state;
        char tail[2] = {0xA3A3,0xA3A3}; // 包尾
        memcpy(buf,(char *)(&header),sizeof(DataHeader));
        len +=sizeof(DataHeader);
        memcpy(buf+leb,(char *)(&heart),sizeof(DataHeart));
        len +=sizeof(DataHeart);
        memcpy(buf+leb,tail,2); 
        len+=2;
        return true;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51