一、 将基础项目转为byte数组存款和储蓄

 1  private byte[] CreateNetDataByteStream(ushort system, ushort host, ushort type, byte[] tx_buf, ushort msg_len, ushort flag)
 2 
 3         {
 4 
 5             if (tx_buf == null)
 6 
 7             {
 8 
 9                 return null;
10 
11             }
12 
13             try
14 
15             {
16 
17                 byte[] data = new byte[msg_len + NetDataHeadLen];
18 
19                 byte[] u16byte = new byte[2];
20 
21                 u16byte = BitConverter.GetBytes(type);
22 
23                 Array.Copy(u16byte, 0, data, 0, 2);
24 
25                 u16byte = BitConverter.GetBytes(flag);
26 
27                 Array.Copy(u16byte, 0, data, 4, 2);
28 
29                 u16byte = BitConverter.GetBytes(msg_len);
30 
31                 Array.Copy(u16byte, 0, data, 2, 2);
32 
33                // u16byte = BitConverter.GetBytes(CommonConstant.MySystemID);
34 
35                 Array.Copy(u16byte, 0, data, 6, 2);
36 
37               //  u16byte = BitConverter.GetBytes((ushort)CommonConstant.MySeatName);
38 
39                 Array.Copy(u16byte, 0, data, 8, 2);
40 
41                 u16byte = BitConverter.GetBytes(system);
42 
43                 Array.Copy(u16byte, 0, data, 15, 2);
44 
45                 u16byte = BitConverter.GetBytes(host);
46 
47                 Array.Copy(u16byte, 0, data, 17, 2);
48 
49                 tx_buf.CopyTo(data, NetDataHeadLen);
50 
51                 return data;
52 
53             }
54 
55             catch
56 
57             {
58                 return null;
59 
60             }
61 
62         }

2.C#中布局体 与 字节流 相互转化

       

方式一
        //将一个结构序列化为字节数组
               private IFormatter formatter = new BinaryFormatter();
        private ValueType deserializeByteArrayToInfoObj(byte[] bytes)
        {
            ValueType vt;
            if (bytes == null || bytes.Length == 0)
            {
                return null;
            }

            try
            {
                MemoryStream stream = new MemoryStream(bytes);
                stream.Position = 0;
                stream.Seek(0, SeekOrigin.Begin);
                vt = (ValueType)formatter.Deserialize(stream);
                stream.Close();
                return vt;
            }
            catch (Exception ex)
            {
                return null;
            }
        }
        //将一个结构序列化为字节数组
        private byte[] serializeInfoObjToByteArray(ValueType infoStruct)
        {
            if (infoStruct == null)
            {
                return null;
            }

            try
            {
                MemoryStream stream = new MemoryStream();
                formatter.Serialize(stream, infoStruct);

                byte[] bytes = new byte[(int)stream.Length];
                stream.Position = 0;
                int count = stream.Read(bytes, 0, (int)stream.Length);
                stream.Close();
                return bytes;
            }
            catch (Exception ex)
            {
                return null;
            }
        }

方式二
   /// <summary>
        /// 将字节数组转换为结构体
        /// </summary>
        /// <param name="bytes"></param>
        /// <param name="type"></param>
        /// <returns></returns>
        public object ByteaToStruct(byte[] bytes, Type type)
        {
            //得到结构体大小
            int size = Marshal.SizeOf(type);
            Math.Log(size, 1);

            if (size > bytes.Length)
                return null;
            //分配结构大小的内存空间
            IntPtr structPtr = Marshal.AllocHGlobal(size);
            //将BYTE数组拷贝到分配好的内存空间
            Marshal.Copy(bytes, 0, structPtr, size);
            //将内存空间转换为目标结构
            object obj = Marshal.PtrToStructure(structPtr, type);
            //释放内容空间
            Marshal.FreeHGlobal(structPtr);
            return obj;
        }
        /// <summary>
        /// 将结构转换为字节数组
        /// </summary>
        /// <param name="obj"></param>
        /// <returns></returns>
        public byte[] StructTOBytes(object obj)
        {
            int size = Marshal.SizeOf(obj);
            //创建byte数组
            byte[] bytes = new byte[size];
            IntPtr structPtr = Marshal.AllocHGlobal(size);
            //将结构体拷贝到分配好的内存空间
            Marshal.StructureToPtr(obj, structPtr, false);
            //从内存空间拷贝到byte数组
            Marshal.Copy(structPtr, bytes,0, size);
            //释放内存空间
            Marshal.FreeHGlobal(structPtr);
            return bytes;
        }

3. C# 结构体字节对齐

1 [structLayout(Layoutkind.sequential,charset=charset.ansi)]
2 Struct Mystruct
3 {
4 [MarshalAs(UnmanagedType.ByValArray,sizeConst=8)]
5 Public byte[] serial;
6 Public byte Type;
7 Public uint Sum;
8 }

在上述结构体与字节流转换第三种办法中,获取结构体长度int size =
马尔斯hal.SizeOf(Mystruct);,并不是一三,而是1⑥。在内部存储器特定类型数据结构早先地址平时有早晚的对齐供给,比如三十三人机器的int先河地址必须是四的整好几倍,结构平日也如此

内需添加[structLayout(Layoutkind.sequential,charset=charset.ansi,pack=1)]

C# 将结构体转为字节流的措施,

一、 将基础项目转为byte数组存款和储蓄

 1  private byte[] CreateNetDataByteStream(ushort system, ushort host, ushort type, byte[] tx_buf, ushort msg_len, ushort flag)
 2 
 3         {
 4 
 5             if (tx_buf == null)
 6 
 7             {
 8 
 9                 return null;
10 
11             }
12 
13             try
14 
15             {
16 
17                 byte[] data = new byte[msg_len + NetDataHeadLen];
18 
19                 byte[] u16byte = new byte[2];
20 
21                 u16byte = BitConverter.GetBytes(type);
22 
23                 Array.Copy(u16byte, 0, data, 0, 2);
24 
25                 u16byte = BitConverter.GetBytes(flag);
26 
27                 Array.Copy(u16byte, 0, data, 4, 2);
28 
29                 u16byte = BitConverter.GetBytes(msg_len);
30 
31                 Array.Copy(u16byte, 0, data, 2, 2);
32 
33                // u16byte = BitConverter.GetBytes(CommonConstant.MySystemID);
34 
35                 Array.Copy(u16byte, 0, data, 6, 2);
36 
37               //  u16byte = BitConverter.GetBytes((ushort)CommonConstant.MySeatName);
38 
39                 Array.Copy(u16byte, 0, data, 8, 2);
40 
41                 u16byte = BitConverter.GetBytes(system);
42 
43                 Array.Copy(u16byte, 0, data, 15, 2);
44 
45                 u16byte = BitConverter.GetBytes(host);
46 
47                 Array.Copy(u16byte, 0, data, 17, 2);
48 
49                 tx_buf.CopyTo(data, NetDataHeadLen);
50 
51                 return data;
52 
53             }
54 
55             catch
56 
57             {
58                 return null;
59 
60             }
61 
62         }

2.C#中布局体 与 字节流 相互转化

       

方式一
        //将一个结构序列化为字节数组
               private IFormatter formatter = new BinaryFormatter();
        private ValueType deserializeByteArrayToInfoObj(byte[] bytes)
        {
            ValueType vt;
            if (bytes == null || bytes.Length == 0)
            {
                return null;
            }

            try
            {
                MemoryStream stream = new MemoryStream(bytes);
                stream.Position = 0;
                stream.Seek(0, SeekOrigin.Begin);
                vt = (ValueType)formatter.Deserialize(stream);
                stream.Close();
                return vt;
            }
            catch (Exception ex)
            {
                return null;
            }
        }
        //将一个结构序列化为字节数组
        private byte[] serializeInfoObjToByteArray(ValueType infoStruct)
        {
            if (infoStruct == null)
            {
                return null;
            }

            try
            {
                MemoryStream stream = new MemoryStream();
                formatter.Serialize(stream, infoStruct);

                byte[] bytes = new byte[(int)stream.Length];
                stream.Position = 0;
                int count = stream.Read(bytes, 0, (int)stream.Length);
                stream.Close();
                return bytes;
            }
            catch (Exception ex)
            {
                return null;
            }
        }

方式二
   /// <summary>
        /// 将字节数组转换为结构体
        /// </summary>
        /// <param name="bytes"></param>
        /// <param name="type"></param>
        /// <returns></returns>
        public object ByteaToStruct(byte[] bytes, Type type)
        {
            //得到结构体大小
            int size = Marshal.SizeOf(type);
            Math.Log(size, 1);

            if (size > bytes.Length)
                return null;
            //分配结构大小的内存空间
            IntPtr structPtr = Marshal.AllocHGlobal(size);
            //将BYTE数组拷贝到分配好的内存空间
            Marshal.Copy(bytes, 0, structPtr, size);
            //将内存空间转换为目标结构
            object obj = Marshal.PtrToStructure(structPtr, type);
            //释放内容空间
            Marshal.FreeHGlobal(structPtr);
            return obj;
        }
        /// <summary>
        /// 将结构转换为字节数组
        /// </summary>
        /// <param name="obj"></param>
        /// <returns></returns>
        public byte[] StructTOBytes(object obj)
        {
            int size = Marshal.SizeOf(obj);
            //创建byte数组
            byte[] bytes = new byte[size];
            IntPtr structPtr = Marshal.AllocHGlobal(size);
            //将结构体拷贝到分配好的内存空间
            Marshal.StructureToPtr(obj, structPtr, false);
            //从内存空间拷贝到byte数组
            Marshal.Copy(structPtr, bytes,0, size);
            //释放内存空间
            Marshal.FreeHGlobal(structPtr);
            return bytes;
        }

3. C# 结构体字节对齐

1 [structLayout(Layoutkind.sequential,charset=charset.ansi)]
2 Struct Mystruct
3 {
4 [MarshalAs(UnmanagedType.ByValArray,sizeConst=8)]
5 Public byte[] serial;
6 Public byte Type;
7 Public uint Sum;
8 }

在上述结构体与字节流转换第二种办法中,获取结构体长度int size =
马尔斯hal.SizeOf(Mystruct);,并不是一③,而是1陆。在内部存款和储蓄器特定项目数据结构先导地址日常有必然的对齐要求,比如3二个人机器的int初始地址必须是4的平头倍,结构日常也如此

必要添加[将结构体转为字节流的法门。structLayout(Layoutkind.sequential,charset=charset.ansi,pack=1)]

转自:

一、 将基础项目转为byte数组存款和储蓄

 1  private byte[] CreateNetDataByteStream(ushort system, ushort host, ushort type, byte[] tx_buf, ushort msg_len, ushort flag)
 2 
 3         {
 4 
 5             if (tx_buf == null)
 6 
 7             {
 8 
 9                 return null;
10 
11             }
12 
13             try
14 
15             {
16 
17                 byte[] data = new byte[msg_len + NetDataHeadLen];
18 
19                 byte[] u16byte = new byte[2];
20 
21                 u16byte = BitConverter.GetBytes(type);
22 
23                 Array.Copy(u16byte, 0, data, 0, 2);
24 
25                 u16byte = BitConverter.GetBytes(flag);
26 
27                 Array.Copy(u16byte, 0, data, 4, 2);
28 
29                 u16byte = BitConverter.GetBytes(msg_len);
30 
31                 Array.Copy(u16byte, 0, data, 2, 2);
32 
33                // u16byte = BitConverter.GetBytes(CommonConstant.MySystemID);
34 
35                 Array.Copy(u16byte, 0, data, 6, 2);
36 
37               //  u16byte = BitConverter.GetBytes((ushort)CommonConstant.MySeatName);
38 
39                 Array.Copy(u16byte, 0, data, 8, 2);
40 
41                 u16byte = BitConverter.GetBytes(system);
42 
43                 Array.Copy(u16byte, 0, data, 15, 2);
44 
45                 u16byte = BitConverter.GetBytes(host);
46 
47                 Array.Copy(u16byte, 0, data, 17, 2);
48 
49                 tx_buf.CopyTo(data, NetDataHeadLen);
50 
51                 return data;
52 
53             }
54 
55             catch
56 
57             {
58                 return null;
59 
60             }
61 
62         }

2.C#中结构体 与 字节流 相互转化

       

方式一
        //将一个结构序列化为字节数组
               private IFormatter formatter = new BinaryFormatter();
        private ValueType deserializeByteArrayToInfoObj(byte[] bytes)
        {
            ValueType vt;
            if (bytes == null || bytes.Length == 0)
            {
                return null;
            }

            try
            {
                MemoryStream stream = new MemoryStream(bytes);
                stream.Position = 0;
                stream.Seek(0, SeekOrigin.Begin);
                vt = (ValueType)formatter.Deserialize(stream);
                stream.Close();
                return vt;
            }
            catch (Exception ex)
            {
                return null;
            }
        }
        //将一个结构序列化为字节数组
        private byte[] serializeInfoObjToByteArray(ValueType infoStruct)
        {
            if (infoStruct == null)
            {
                return null;
            }

            try
            {
                MemoryStream stream = new MemoryStream();
                formatter.Serialize(stream, infoStruct);

                byte[] bytes = new byte[(int)stream.Length];
                stream.Position = 0;
                int count = stream.Read(bytes, 0, (int)stream.Length);
                stream.Close();
                return bytes;
            }
            catch (Exception ex)
            {
                return null;
            }
        }

方式二
   /// <summary>
        /// 将字节数组转换为结构体
        /// </summary>
        /// <param name="bytes"></param>
        /// <param name="type"></param>
        /// <returns></returns>
        public object ByteaToStruct(byte[] bytes, Type type)
        {
            //得到结构体大小
            int size = Marshal.SizeOf(type);
            Math.Log(size, 1);

            if (size > bytes.Length)
                return null;
            //分配结构大小的内存空间
            IntPtr structPtr = Marshal.AllocHGlobal(size);
            //将BYTE数组拷贝到分配好的内存空间
            Marshal.Copy(bytes, 0, structPtr, size);
            //将内存空间转换为目标结构
            object obj = Marshal.PtrToStructure(structPtr, type);
            //释放内容空间
            Marshal.FreeHGlobal(structPtr);
            return obj;
        }
        /// <summary>
        /// 将结构转换为字节数组
        /// </summary>
        /// <param name="obj"></param>
        /// <returns></returns>
        public byte[] StructTOBytes(object obj)
        {
            int size = Marshal.SizeOf(obj);
            //创建byte数组
            byte[] bytes = new byte[size];
            IntPtr structPtr = Marshal.AllocHGlobal(size);
            //将结构体拷贝到分配好的内存空间
            Marshal.StructureToPtr(obj, structPtr, false);
            //从内存空间拷贝到byte数组
            Marshal.Copy(structPtr, bytes,0, size);
            //释放内存空间
            Marshal.FreeHGlobal(structPtr);
            return bytes;
        }

3. C# 结构体字节对齐

1 [structLayout(Layoutkind.sequential,charset=charset.ansi)]
2 Struct Mystruct
3 {
4 [MarshalAs(UnmanagedType.ByValArray,sizeConst=8)]
5 Public byte[] serial;
6 Public byte Type;
7 Public uint Sum;
8 }

在上述结构体与字节流转换第两种方法中,获取结构体长度int size =
马尔斯hal.SizeOf(Mystruct);,并不是1三,而是16。在内存特定项目数据结构伊始地址平常有一定的对齐要求,比如三十二人机器的int发轫地址必须是4的平头倍,结构平时也如此

亟待添加[structLayout(Layoutkind.sequential,charset=charset.ansi,pack=1)]

将结构体转为字节流的办法, 一、
将基础项目转为byte数组存款和储蓄 1 private byte [] CreateNetDataByteStream(
ushort system, ushort host, ushort type, byte [] tx…

1. 结构体(struct)

一.一 结构体的概念

  • 结构体(struct):是由一名目繁多具有同等体系或区别类型的多少整合的多少集合,叫做结构。
  • 结构体(struct):是1种复合数据类型,结构类型。
  • 注:“结构”是一种构造类型,它是由若干“成员”组成的。
    每1个分子能够是三个主导数据类型大概又是两个构造类型。
    结构即是1种“构造”而成的数据类型,
    那么在印证和应用之前务必先定义它,相当于组织它。就好像在表达和调用函数在此之前要先定义一样。

一.二 C语言中的结构体

  • 说明:在C语言中,结构体(struct)是复合数据类型的壹种。同时也是某个成分的集合,这一个成分称为结构体的成员,且这几个分子可以为分化的花色,成员壹般用名字访问。结构体能够被声称为变量、指针或数组等,用以完毕较复杂的数据结构。
  • 注:在C语言中,结构体不可能包括函数。
  • 概念与注脚: (一)示例代码一:

    1 struct tag 
    2 {
    3     member-list
    4 }variable-list;
    5 注:struct为结构体关键字;
    6    tag为结构体的标志;
    7    member-list为结构体成员变量列表,其必须列出其所有成员;
    8    variable-list为此结构体声明的变量;
    

    (二)示例代码贰:

     1 //此声明声明了拥有3个成员的结构体,分别为整型的a,字符型的b和双精度的c,但没有标明其标签,声明了结构体变量s1
     2 struct 
     3 {
     4     int a;
     5     char b;
     6     double c;
     7 } s1;
     8 
     9 //此声明声明了拥有3个成员的结构体,分别为整型的a,字符型的b和双精度的c,结构体的标签被命名为SIMPLE,用SIMPLE标签的结构体,另外声明了变量t1, t2[20], *t3
    10 struct SIMPLE
    11 {
    12     int a;
    13     char b;
    14     double c;
    15 };
    16 SIMPLE t1, t2[20], *t3; 
    17 
    18 //可以用typedef创建新类型,此声明声明了拥有3个成员的结构体,分别为整型的a,字符型的b和双精度的c,结构体的标签被命名为Simple2,用Simple2作为类型声明新的结构体变量u1, u2[20], *u3
    19 typedef struct
    20 {
    21     int a;
    22     char b;
    23     double c; 
    24 } Simple2;
    25 Simple2 u1, u2[20], *u3;//若去掉typedef则编译报错,error C2371: “Simple2”: 重定义;不同的基类型
    26 
    27 注:在上面的声明中,第一个和第二声明被编译器当作两个完全不同的类型,即使他们的成员列表是一样的,如果令t3=&s1,则是非法的。
    

    注:在相似意况下,tag、member-list、variable-list那3局地最少要出新一个。

壹.3 C++中的结构体

  • 说明:在C语言中,结构体不能够包括函数。在面向对象的主次设计中,对象具备状态(属性)和行为,状态保存在成员变量中,行为经过分子方法(函数)来完结。C语言中的结构体只可以描述1个对象的情景,不可能描述1个目的的表现。在C++中,思虑到C语言到C++语言过渡的一连性,对结构体进行了扩展,C++的结构体能够涵盖函数,那样,C++的结构体也拥有类的作用,与class分裂的是,结构体包罗的函数暗中同意为public,而不是private。
  • 注:在C++中,结构体能够涵盖函数。
  • 概念与表明:

  • 金沙注册送58,(一)示例代码壹:

    1 struct tag 
    2 {
    3     member-list
    4 }variable-list;
    5 注:struct为结构体关键字;
    6    tag为结构体的标志;
    7    member-list为结构体成员变量及成员函数列表,其必须列出其所有成员;
    8    variable-list为此结构体声明的变量;
    

    (二)示例代码二:

     1 #include <iostream> 
     2 
     3 using namespace std;
     4 
     5 struct SAMPLE
     6 {
     7     int x;
     8     int y;
     9     int add() {return x+y;}
    10 }s1;
    11 
    12 int main()
    13 {
    14     cout<<"没初始化成员变量的情况下:"<<s1.add()<<endl;
    15     s1.x = 3;
    16     s1.y = 4;
    17     cout<<"初始化成员变量的情况下:"<<s1.add()<<endl;
    18     system("pause");
    19     return 0;
    20 }
    21 =>没初始化成员变量的情况下:0
    22   初始化成员变量的情况下:7
    

    C++中的结构体与类的界别:
    (1)class中暗中同意的分子访问权限是private的,而struct中则是public的。
    (二)class继承暗中同意是private继承,而从struct继承私下认可是public继承。

一.四 结构体的效益

  • 在实际上项目中,结构体是大度设有的。研究开发人士常选用结构体来封装一些脾性来组成新的门类。由于C语言内部程序比较简单,研究开发职员常见采纳结构体创设新的“属性”,其指标是简化运算。
  • 结构体在函数中的功用不是近水楼台先得月,最要紧的效能正是包裹。卷入的利益便是能够重新使用。让使用者不必关切这一个是哪些,只要按照定义使用就足以了。

一.5 结构体的尺寸与内部存款和储蓄器对齐

  • 暗许的对齐方式:各成员变量在存放的时候依据在构造中冒出的顺序依次申请空间,同时依照上面的对齐格局调整任务,空缺的字节VC会自动填写。同时VC为了保障协会的高低为结构的字节边界数(即该组织中占据最大空间的项目所占用的字节数)的倍数,所以在为最后一个分子变量申请空间后,还会根据必要活动填充空缺的字节。

  • 注:VC对变量存款和储蓄的3个异样处理。为了增加CPU的贮存速度,VC对有些变量的苗子地址做了“对齐”处理。在默许意况下,VC规定各成员变量存放的开地方址相对于组织的序曲地址的偏移量必须为该变量的体系所占据的字节数的倍数。

  • (一)示例代码1:

    1 struct MyStruct
    2 {
    3     double dda1;
    4     char dda;
    5     int type;
    6 };
    7 //错:sizeof(MyStruct)=sizeof(double)+sizeof(char)+sizeof(int)=13。
    8 //对:当在VC中测试上面结构的大小时,你会发现sizeof(MyStruct)为16。
    

    注:为地点的社团分配空间的时候,VC依据成员变量出现的相继和对齐情势。

  • (一)先为第多少个分子dda1分配空间,其开首地址跟结构的苗头地址1样(刚好偏移量0刚好为sizeof(double)的翻番),该成员变量占用sizeof(double)=几个字节;

  • (二)接下去为第一个成员dda分配空间,那时下二个能够分配的地址对于组织的发端地址的偏移量为8,是sizeof(char)的倍数,所以把dda存放在偏移量为八的地点满意对齐格局,该成员变量占用sizeof(char)=三个字节;

  • (叁)接下去为第多少个成员type分配空间,那时下四个得以分配的地址对于协会的开局部址的偏移量为玖,不是sizeof(int)=四的翻番,为了满足对齐情势对偏移量的封锁难题,VC自动填充二个字节(那七个字节未有放什么东西),那时下二个足以分配的地点对于组织的起先地址的偏移量为1二,刚好是sizeof(int)=4的翻番,所以把type存放在偏移量为12的地点,该成员变量占用sizeof(int)=5个字节;
  • 那儿整个结构的积极分子变量已经都分配了上空,总的占用的空中尺寸为:8+1+三+四=16,刚好为组织的字节边界数(即协会中据为己有最大空间的档次所占有的字节数sizeof(double)=八)的倍数,所以未有空缺的字节须求填写。所以任何结构的轻重为:sizeof(MyStruct)=八+一+三+四=16,在这之中有二个字节是VC自动填充的,未有扬弃何有含义的事物。

  • (2)示例代码2:交流一下上述例子中MyStruct的分子变量的任务

  • 1 struct MyStruct

    2 {
    3     char dda;
    4     double dda1;
    5     int type;
    6 };
    7 //错:sizeof(MyStruct)=sizeof(double)+sizeof(char)+sizeof(int)=13。
    8 //对:当在VC中测试上面结构的大小时,你会发现sizeof(MyStruct)为24。
    

     

  • 注:为地方的组织分配空间的时候,VC遵照成员变量出现的逐条和对齐格局。

  • (1)先为第一个成员dda分配空间,其开端地址跟结构的开场面址1样(刚好偏移量0刚好为sizeof(char)的倍数),该成员变量占用sizeof(char)=1个字节;

  • (二)接下去为第3个分子dda一分配空间,那时下多少个足以分配的地方对于组织的发轫地址的偏移量为一,不是sizeof(double)=捌的倍数,须求补足多少个字节才能使偏移量变为八(满足对齐情势),因此VC自动填充九个字节,dda1存放在偏移量为八的地点上,它占用八个字节;

  • (三)接下去为第多少个分子type分配空间,那时下一个得以分配的地点对于协会的开局部址的偏移量为1陆,是sizeof(int)=4的翻番,满意int的对齐格局,所以不须求VC自动填充,type存放在偏移量为1陆的地点上,该成员变量占用sizeof(int)=6个字节;
    那时候整个结构的分子变量已经都分配了上空,总的占用的空间尺寸为:1+柒+捌+四=20,不是布局的节边界数(即协会中占据最大空间的类别所占用的字节数sizeof(double)=八)的翻番,所以需求填写七个字节,以满意结构的轻重为sizeof(double)=8的翻番。所以该组织总的大小为:sizeof(MyStruct)为1+七+八+四+4=二四。在那之中总的有柒+四=13个字节是VC自动填充的,未有放别的有意义的事物。

  • 字节的对齐方式:

  • 在VC中提供了#pragmapack(n)来设定变量以n字节对齐格局。n字节对齐正是说变量存放的开首地址的偏移量有二种状态:第二,假诺n大于等于该变量所占据的字节数,那么偏移量必须满意私下认可的对齐情势;第一,假使n小于该变量的品种所占有的字节数,那么偏移量为n的倍数,不用满足暗许的对齐方式。结构的总大小也有个约束原则,分下边二种情景:要是n大于全体成员变量类型所占据的字节数,那么结构的总大小必须为占用空间最大的变量占用的空间数的翻番;否则必须为n的翻番。


注:VC对结构的存储的特殊处理确实提高了CPU存储变量的速度,但有时也会带来一些麻烦,我们也可以屏蔽掉变量默认的对齐方式,自己来设定变量的对齐方式。**
  • (1)示例代码:

     1 #pragmapack(push)//保存对齐状态
     2 
     3 
     4 #pragmapack(4)//设定为4字节对齐
     5 
     6 struct test
     7 {
     8     char m1;
     9     double m4;
    10     int m3;
    11 };
    12 
    13 #pragmapack(pop)//恢复对齐状态
    

     

    注:以上结构的轻重为16,上面分析其储存情况。

  • (1)首先为m一分配空间,其偏移量为0,满足大家休戚与共设定的对齐格局(四字节对齐),m1占用2个字节;

  • (二)接着初步为m五分配空间,那时其偏移量为一,须求补足1个字节,那样使偏移量知足为n=四的倍数(因为sizeof(double)大于n),m四占用八个字节;

  • (三)接着为m3分配空间,那时其偏移量为12,满意为四的翻番,m3占用多少个字节;
    那时已经为持有成员变量分配了上空,共分配了十一个字节,满足为n的翻番。如若把下边包车型地铁#pragmapack(4)改为#pragma
    pack(八),那么大家得以博得结构的高低为二四。

参考文献: 

[1]《C++全方位学习》范磊——第5章 

[2]《C++程序设计教程(第1版)》钱能——第七章  [3]

 百度搜索关键字:结构体、结构体的意义、结构体的轻重缓急与内部存款和储蓄器对齐

相关文章

网站地图xml地图