内部存款和储蓄器映射大文件并采纳Marshal解析结构体音讯,结构体对齐

内部存款和储蓄器映射数据处理类重要函数及变量如下:

转载 结构体对齐详解

二〇一七年九月二二日星期天

结构体:

若干个相同或不相同品种的多寡整合的集纳,构成结构体的数据称为结构体的数量成员。结构体类型是一种自定义的数据类型,不是系统预约义的数据类型,所以在动用从前要证明结构体类型,然后再利用。

结构体的定义和伊始化

struct student{ unsigned num; char name[20]; char sex; int age; float score;}student1,student2;//在声明结构体类型的同时定义结构体变量

抑或struct student a;注解匿名结构体类型,需同时定义结构体变量。truct
student1={288829,”kafdk”,’m’}; //全体早先化,局地伊始化

typedef:给品种起外号与#define之间的界别:

#define INT_Q int* //单纯的替换,不考虑正确性typedef int* INT_R; // 起别名,考虑正确性INT_Q q1,q2;//q1是指针,q2是整型变量INT_R r1,r2;//都是指针,引入了一个新的助记符

结构体变量所占存款和储蓄空间的轻重缓急至少为其之所以成员所占空间的总数,还要考虑字节对齐机制的影响

结构体的走访

average=(student1.soure+student2.soure+student3.soure)/3;//和数组一样,不能整体访问,只能访问它的数据成员//.为成员运算符,作用为获取结构体的数据成员//通过结构体变量的指针访问其数据成员struct student* p=&a1;p->name="ajsdhk"; //->为指向运算符,作用为获取结构体的数据成员printf("%s\n",p->name);//堆区结构体struct book* p=(struct book*)malloc(sizeof(struct book));typedef struck student{ int id;}stu;Stu.id=.id=stu->id//将一个结构体变量赋给另外一个结构体变量;必须类型相同

typedef struct person{ int id; char sex; float sight; char name[100];}person;int main{ person p1; struct person p2; p1.id = 1001;//取结构体成员 等效于:*&p1 = 1001; (取值---转换---指向----赋值) //下面两句编号无区别,内容有区别,基类型不同 &p1;//指向结构体 &;//指向int return 0;}

结构体的输入输出:printf(“%u,%s,%c”,num,name,sex);scanf(“&u,%s,%c”,&student1.num,student1.name,&student.sex);name[]是字符数组,所以不加&

结构体的嵌套使用:结构体的数据成员为布局体类型

 1        string _filepath;
 2        /// <summary>
 3         /// 引用内存映射文件
 4         /// </summary>
 5         private MemoryMappedFile _memoryFile = null;
 6         /// <summary>
 7         /// 用于访问内存映射文件的存取对象
 8         /// </summary>
 9         private MemoryMappedViewAccessor _accessor = null;
10         public ScientificData _ScientificData = new ScientificData();
11         long _lenByte = 0;
12         public DatFileInfo(string filepath)
13         {
14             _filepath = filepath;
15             _memoryFile = MemoryMappedFile.CreateFromFile(_filepath);
16             _accessor = _memoryFile.CreateViewAccessor();
17             // _stream = _memoryFile.CreateViewStream();
18             FileInfo finfo = new FileInfo(filepath);
19             _lenByte = finfo.Length;//文件字节大小
20         }
21         public void SaveRawData(string savepath)
22         {
23             
24             int currentByteNum = 0;//当前字节位置
25             uint ACountint = 0;
26             uint RCountint = 0;
27             ScientificData scientificData = new ScientificData();
28             byte[] data = new byte[1036 * 1036];
29             while (currentByteNum<= (_lenByte- 1036 * 1036))
30             {
31                 _accessor.Read<uint>(currentByteNum, out RCountint);
32                 _accessor.Read<uint>(currentByteNum+4, out ACountint);
33                 if (RCountint < 1400 && ACountint < 1401 && _accessor.ReadByte(currentByteNum+8)==0x0a && _accessor.ReadByte(currentByteNum + 9) == 0x0b)//初步判断条件,节省解析结构体时间
34                 {
35                     _accessor.ReadArray(currentByteNum, data, 0, data.Length);//读取结构体数据到字节数组
36                     scientificData = ByteToStructure<ScientificData>(data);//字节数组解析到结构体
37                     if((scientificData.aux_3a1 == 0x3A) && (scientificData.aux_3a3 == 0x3A))//进一步判断
38                     {
39                         ushort[,] sdata = scientificData.GetImageData();//得到所需的数据
40                         saveRawData(savepath + ((int)((ACountint - 1)/15+1)).ToString()+ "_" + (ACountint-1).ToString() + "_"+ACountint + "_"+scientificData.aux_num + ".raw" , sdata);
41                         currentByteNum += 1036 * 1036;
42                     }
43                     else
44                         currentByteNum++;
45                 }
46                 else
47                     currentByteNum++;
48 
49 
50             }
51         }
52         /// <summary>
53         /// 由byte数组转换为结构体
54         /// </summary>
55         public static T ByteToStructure<T>(byte[] dataBuffer)
56         {
57             object structure = null;
58             int size = Marshal.SizeOf(typeof(T));
59             IntPtr allocIntPtr = Marshal.AllocHGlobal(size);
60             try
61             {
62                 Marshal.Copy(dataBuffer, 0, allocIntPtr, size);
63                 structure = Marshal.PtrToStructure(allocIntPtr, typeof(T));
64             }
65             finally
66             {
67                 Marshal.FreeHGlobal(allocIntPtr);
68             }
69             return (T)structure;
70         }
71         private void saveRawData(string savepath,ushort[,] data)
72         {
73             int len = data.Length*2;
74             byte[] bdata = new byte[len];
75             Buffer.BlockCopy(data,0,bdata,0,len);
76             File.WriteAllBytes(savepath, bdata);
77         }
78         /// <summary>
79         /// 由结构体转换为byte数组
80         /// </summary>
81         public static byte[] StructureToByte<T>(T structure)
82         {
83             int size = Marshal.SizeOf(typeof(T));
84             byte[] buffer = new byte[size];
85             IntPtr bufferIntPtr = Marshal.AllocHGlobal(size);
86             try
87             {
88                 Marshal.StructureToPtr(structure, bufferIntPtr, true);
89                 Marshal.Copy(bufferIntPtr, buffer, 0, size);
90             }
91             finally
92             {
93                 Marshal.FreeHGlobal(bufferIntPtr);
94             }
95             return buffer;
96         }

结构体数据成员对齐的意思

成都百货上千实际的微机系统对基本类型数据在内存中存放的职位有限定,它们会供给这么些数据的初阶地址的值是有些数k的倍数,那正是所谓的内存对齐,而以此k则被号称该数据类型的对齐模数(alignment
modulus)。这种强制的渴求一来简化了计算机与内部存款和储蓄器之间传输种类的安顿性,二来能够升官读取数据的快慢。

比如说那样一种处理器,它每趟读写内部存款和储蓄器的时候都从有些8倍数的地方起首,一遍读出或写入七个字节的数目,假使软件能确定保证double类型的数目都从8倍数地方初始,那么读或写一个double类型数据就只需求二回内部存款和储蓄器操作。不然,大家就大概要求
一遍内存操作才能形成那几个动作,因为数量或然刚刚横跨在七个符合对齐须求的8字节内存块上。

今日新课内容讲了定义和平运动用结构体变量,所谓结构体正是不一样连串数据整合的组合型的数据结构,称为结构体。它与数组分歧,四个数组中不得不存放一个档次的数额。结构体的相似格局为:

一道或公用体:

  1. 公用体类型让多少个不相同类型的变量存放在同四个内部存款和储蓄器区域中,这个变量的开场所址是一模一样的,系统利用的数据值覆盖存款和储蓄的情势使得这几个不一致类别的变量在平等时刻唯有二个能起功效。
  2. 和结构体一样,也是自定义数据类型,用法基本相同,但分化的是结构体的数据成员都有谈得来单独的内部存款和储蓄器空间,而公用体的富有成员公用一块内部存储器空间,全体欧洲经济共同体的首地址相同。
  3. 概念的还要只好用第3个成员的类别的值举办起始化
  4. 公用体所占存款和储蓄空间大小由它的数目成员中占存款和储蓄空间最大的决定
  5. 在某一每一日,唯有2个数据成员有含义
  6. 走访以来被赋值的数目成员才有意义

澳门葡京备用网址,是的数据结构体定义如下:

结构体对齐包括多个方面包车型客车意义

  • 结构中华全国体育总会长度;
  • 协会体内各数据成员的内部存储器对齐,即该数额成员相对结构体的前奏地方;

struct  结构体名

枚举:

也是自定义数据类型,表示取值只有有限种景况的数码enum sex
{male,female};//male,female称为枚举常量其实枚举常量代表三个整数值,暗中同意情形下从0先河枚举值是常量,不是变量。

枚举和共用体的例子:

#include <string.h>#include <stdio.h>#include <stdlib.h>#include <limits.h>enum NumType // 声明一个枚举类型来描述要输出的类型{ INTEGER_INT, // 整型类型 INTEGER_LONG, // 长整型类型 INTEGER_DOUBLE // DOUBLE类型};union NumValue // 声明一个包含下面三种类型的共用体{ int iValue; // int类型值 long lValue; // long类型值 double dValue; // double类型值};int main( int argc, char *argv[] ){ int count = argc - 1; // 计算输入的参数个数 NumValue *Values = new NumValue[count]; // 存放值的共用体 NumType *Types = new NumType[count]; // 存放类型的数组 for( int i = 1; i < argc; ++i ) // 循环处理每个参数 { if( strchr( argv[i], '.' ) != 0 ) // 判断输入参数中是否包含小数点 { Values[i].dValue = atof( argv[i] ); // 为dValue成员赋值,并记录类型。 Types[i] = INTEGER_DOUBLE; // 记录数组的成员的类型为DOUBLE型 } else // 不是Floating类型 { if (( atol( argv[i] ) > INT_MAX ) || (atol( argv[i] ) < 0)) { // 如果数据大于int类型的最大值,则将其存储在lValue成员中,并记录类型 Values[i].lValue = atol( argv[i] ); // 将值转换成长整型 Types[i] = INTEGER_LONG; // 记录数组的成员的类型为长整型 } else { // 否则,将其存储在iValue成员中,并记录类型 Values[i].iValue = atoi( argv[i] ); // 将值转换成整型 Types[i] = INTEGER_INT; // 记录数组的成员的类型为整型 } } switch( Types[i] ) // 根据类型种类,将种类信息和值信息输出 { case INTEGER_INT: // 如果数据为整型,输出整型值 printf( "数据类型为Integer,值为%d\n", Values[i].iValue ); break; case INTEGER_LONG: // 如果数据为长整型,输出长整型值 printf( "数据类型为Long,值为%d\n", Values[i].lValue ); break; case INTEGER_DOUBLE: // 如果数据为double型,输出double值 printf( "数据类型为Double,值为%f\n", Values[i].dValue ); break; } } //system; return 0;}
  //一幅1036*1036字节数据定义
    public struct ScientificData
     {
        /参数信息
     [MarshalAs(UnmanagedType.ByValArray, SizeConst = 4)]
       public byte[] RelativePacketCount;
      [MarshalAs(UnmanagedType.ByValArray, SizeConst = 4)]
       public Byte[] AbsolutePacketCount;
     ........
      public byte aux_3a;//填充3A H
       .........
      [MarshalAs(UnmanagedType.ByValArray, SizeConst = 1036)]
        public OneImageRow[] ImageData;//图像数据行
/// <summary>
/// 获取raw图数据
/// </summary>
/// <returns>图像数据</returns>
public ushort[,] GetImageData()
{
ushort[,] rawdata = new ushort[1036, 512];
for (int i = 0; i < 1036; i++)
{
var onerow = ImageData[i];
for (int j = 0; j < 512; j++)
{
rawdata[i, j] = (ushort)(((onerow.imagedata[j * 2] << 8) | onerow.imagedata[j * 2 + 1])) ;
}
}
return rawdata;
}
}

结构体大小的估计方法和步骤

  1. 将协会体内全数数据成员的长度值相加,记为sum_a;
  1. 将各数据成员为了内部存款和储蓄器对齐,按各自对齐模数而填充的字节数累加到和sum_a上,记为sum_b。对齐模数是#pragma pack
    钦点的数值以及该数量成员本人长度中数值较小者。该数额相对发轫地方应该是对齐格局的整数倍;
  2. 将和sum_b向结构人体模型数对齐,该模数是 #pragma pack指定的数值
    未指定#pragma pack时,系统默认的对齐模数(32位系统为4字节,64位为8字节)
    结构体内部最大的基本数据类型成员内部存款和储蓄器映射大文件并采纳Marshal解析结构体音讯,结构体对齐。
    长度中数值较小者。结构体的长短应该是该模数的整数倍。

          {成员列表};

图像数据结构体如下:

结构体大小总计举例

在盘算以前,大家第②须要肯定的是种种数据成员的对齐模数,对齐模数和数据成员自个儿的长度以及pragma
pack编写翻译参数有关,其值是两岸中幽微数。借使程序没有鲜明提出,就须求知道编写翻译器暗许的对齐模数值。下表是Windows
XP/DEV-C++和Linux/GCC中挑郑城数据类型的尺寸和私下认可对齐模数。

char short int long float double long long long double
Win-32长度 1 2 4 4 4 8 8 8
模数 1 2 4 4 4 8 8 8
Linux-32长度 1 2 4 4 4 8 8 12
模数 1 2 4 4 4 4 4 4
Linux-64长度 1 2 4 8 4 8 8 16
模数 1 2 4 8 4 8 8 16

该方式为结构体类型,不过为了能在程序中动用结构体类型的数量,还应有定义结构体类型的数目,并在其间存放具体的数码。定义结构体类型变量有两种办法:

 

例子1:

struct my_struct 
{ 
    char a; 
    long double b; 
};

此例子Windows和Linux总计办法有个别许不等同。

在Windows中计算步骤如下:

  1. 怀有数据成员自个儿长度和:1B + 8B = 9B –> sum_a = 9B
  1. 数码成员a放在相对偏移0处,此前不须求填充字节;数据成员b为了内部存款和储蓄器对齐,依据“结构体大小的计量方法和步子”中第一条规则,其对齐模数是8,在此以前需填充多少个字节,sum_a +
    7 = 16B –> sum_b = 16 B
  2. 根据定义,结构体对齐模数是结构体内部最大数额成员长度和pragma
    pack中较小者,前者为8后者为4,所以结构体对齐模数是4。sum_b是4的4倍,不需另行对齐。

综上3步,可见结构体的长短是16B,各数据成员在内部存款和储蓄器中的分布如图1-1所示。

在Linux中总计步骤如下:

  1. 有着数据成员自个儿长度和:1B + 12B = 13B –> sum_a = 13B
  1. 数量成员a放在相对偏移0处,从前不必要填充字节;数据成员b为了内存对齐,依照“结构体大小的估算方法和步骤”中第壹条规则,其对齐模数是4,此前需填充2个字节,sum_a +
    3 = 16B –> sum_b = 16 B
  2. 遵从定义,结构体对齐模数是结构体内部最大数量成员长度和pragma
    pack中较小者,前者为12继任者为4,所以结构体对齐模数是4。sum_b是4的4倍,不需另行对齐。

综上3步,可见结构体的长短是16B,各数据成员在内部存款和储蓄器中的分布如图1-2所示。

澳门葡京备用网址 1

本人是图片.jpg

1.先宣称结构体类型,在概念该项指标变量

 

例子2:

#pragma pack(2) 
struct my_struct 
{ 
    char a; 
    long double b; 
}; 
#pragma pack()

事例1和例子2不一致之处在于例子第22中学使用了 #pragma pack(2)
编译参数,它强制钦赐对齐模数是2。此例子Windows和Linux总计形式有个别许区别等。

在Windows中总括步骤如下:

  1. 怀有数据成员本人长度和:1B + 8B = 13B –> sum_a = 9B
  1. 多少成员a放在相对偏移0处,在此之前不须求填充字节;数据成员b为了内部存款和储蓄器对齐,依据“结构体大小的一个钱打二14个结格局和步骤”中第②条标准,其对齐模数是2,以前需填充贰个字节,sum_a +
    1 = 10B –> sum_b = 10 B
  2. 依据定义,结构体对齐模数是结构体内部最大数据成员长度和pragma
    pack中较小者,前者为8后者为2,所以结构体对齐模数是2。sum_b是2的5倍,不需重新对齐。

综上3步,可见结构体的尺寸是10B,各数据成员在内部存款和储蓄器中的分布如图2-1所示。

在Linux中总括步骤如下:

  1. 有着数据成员自个儿长度和:1B + 12B = 13B –> sum_a = 13B
  1. 数码成员a放在相对偏移0处,从前不须要填充字节;数据成员b为了内存对齐,依照“结构体大小的乘除方式和手续”中第②条标准,其对齐模数是2,在此以前需填充三个字节,sum_a +
    1 = 14B –> sum_b = 14 B
  2. 遵从定义,结构体对齐模数是结构体内部最大数目成员长度和pragma
    pack中较小者,前者为8后者为2,所以结构体对齐模数是2。sum_b是2的7倍,不需重新对齐。

综上3步,可见结构体的尺寸是14B,各数据成员在内部存款和储蓄器中的分布如图2-2所示。

澳门葡京备用网址 2

本人是图片.jpg

2.在宣称类型的同时定义结构体变量

    public struct OneImageRow
    {
        [MarshalAs(UnmanagedType.ByValArray, SizeConst = 4)]
        public byte[] RelativePacketCount;
        [MarshalAs(UnmanagedType.ByValArray, SizeConst = 4)]
        public byte[] AbsolutePacketCount;
        [MarshalAs(UnmanagedType.ByValArray, SizeConst = 2)]
        public byte[] linehead;//行头
        [MarshalAs(UnmanagedType.ByValArray, SizeConst = 2)]
        public byte[] linenum;//行号
        [MarshalAs(UnmanagedType.ByValArray, SizeConst = 1024)]
        public byte[] imagedata;//图像数据512×2=1024字节

        public static string ByteToHex(byte[] bt)
        {
            var hex = BitConverter.ToString(bt, 0).ToUpper();
            return hex;
        }
    }

例子3:

struct my_struct 
{ 
    char a; 
    double b; 
    char c; 
}; 

前两例中,数据成员在Linux和Windows下都平等,例3中double的对齐模数在Linux中是4,在Windows下是8,针对那种模数不等同的情景加以分析。

在Windows中总括步骤如下:

  1. 持有数据成员自己长度和:1B + 8B + 1B = 10B –> sum_a = 10B
  1. 多少成员a放在相对偏移0处,从前不需求填充字节;数据成员b为了内部存款和储蓄器对齐,依据“结构体大小的测算方法和步子”中第贰条规则,其对齐模数是8,在此以前需填充7个字节,sum_a +
    7 = 17B –> sum_b = 17B
  2. 根据定义,结构体对齐模数是结构体内部最大数额成员长度和pragma
    pack中较小者,前者为8后者为8,所以结构体对齐模数是8。sum_b应该是8的平头倍,所以要在结构体后填充8*3 –
    17 = 7个字节。

综上3步,可见结构体的长短是24B,各数据成员在内部存款和储蓄器中的分布如图3-1所示。

在Linux中总结步骤如下:

  1. 怀有数据成员本身长度和:1B + 8B + 1B = 10B,sum_a = 10B
  1. 数码成员a放在相对偏移0处,在此以前不必要填充字节;数据成员b为了内部存款和储蓄器对齐,依据“结构体大小的持筹握算方法和步骤”中第3条规则,其对齐模数是4,此前需填充3个字节,sum_b
    = sum_a + 3 = 13B
  2. 根据定义,结构体对齐模数是结构体内部最大数量成员长度和pragma
    pack中较小者,前者为8后者为4,所以结构体对齐模数是4。sum_b应该是4的整数倍,所以要在结构体后填充4*4 –
    13 = 3个字节。

综上3步,可见结构体的长度是16B,各数据成员在内部存款和储蓄器中的分布如图3-2所示。

澳门葡京备用网址 3

本人是图片.jpg

3.不钦命项目名而直白定义结构体变量

 

例子4:

struct my_struct 
{ 
    char a[11]; 
    int b; 
    char c; 
}; 

此例子Windows和Linux计算格局同样,如下:

  1. 具有数据成员自己长度和:11B + 4B + 1B = 16B –> sum_a = 16B
  1. 多少成员a放在相对偏移0处,从前不须要填充字节;数据成员b为了内部存款和储蓄器对齐,依据“结构体大小的计量方法和步子”中第①条规则,其对齐模数是4,在此之前需填充三个字节,sum_a +
    1 = 17B –> sum_b = 17B
  2. 依据定义,结构体对齐模数是结构体内部最大数额成员长度和pragma
    pack中较小者,前者为4后者为4,所以结构体对齐模数是4。sum_b是4的平头倍,需在结构体后填充4*5 –
    17 = 1个字节。

综上3步,可见结构体的长短是20B,各数据成员在内部存款和储蓄器中的分布如图4所示。

澳门葡京备用网址 4

笔者是图片.jpg

在概念结构体碧昂粮食,能够对它初步化,即予以初步值,然后能够引用这一个变量。

例子5:

struct my_test 
{ 
    int my_test_a; 
    char my_test_b; 
}; 

struct my_struct 
{ 
    struct my_test a; 
    double my_struct_a; 
    int my_struct_b; 
    char my_struct_c; 
};

事例5和前多少个例子均区别,在此例子中我们要总计struct
my_struct的大小,而my_struct中嵌套了3个my_test结构体。这种结构体应该怎么样总结呢?原则是将my_test在my_struct中先举办,然后再计算,就是展开成如下结构体:

struct my_struct
{
    int my_test_a;
    char my_test_b;
    double my_struct_a;
    int my_struct_b;
    char my_struct_c;
}; 

此例子Windows中的总结格局如下:

  1. 怀有数据成员自己长度和:4B + 1B + 8B + 4B + 1B= 18B –> sum_a
    = 18B
  1. 多少成员my_struct_a为了内部存款和储蓄器对齐,依照“结构体大小的测算办法和步子”中第②条规则,其对齐模数是8,以前需填充一个字节:sum_a +
    3 = 21B –> sum_b = 21B
  2. 根据定义,结构体对齐模数是结构体内部最大数据成员长度和pragma
    pack中较小者,前者为8后者为8,所以结构体对齐模数是8。sum_b是8的整数倍,需在结构体后填充3*8 –
    21 = 3个字节。

综上3步,可见结构体的长短是24B,各数据成员在内存中的分布如图5所示。

此例子Linux中的总计格局如下:

  1. 有着数据成员本人长度和:4B + 1B + 8B + 4B + 1B= 18B,sum_a = 18B
  2. 数码成员my_struct_a为了内部存款和储蓄器对齐,根据“结构体大小的一个钱打二十六个结方法和步子”中第一条规则,其对齐模数是4,在此之前需填充三个字节,sum_b
    = sum_a + 3 = 21B
  3. 依据定义,结构体对齐模数是结构体内部最大数目成员长度和pragma
    pack中较小者,前者为4后者为4,所以结构体对齐模数是4。sum_b是4的平头倍,需在结构体后填充6*4 –
    21 = 3个字节。

综上3步,可见结构体的长度是24B,各数据成员在内部存款和储蓄器中的分布如图5所示。

澳门葡京备用网址 5

本人是图片.jpg

中午上半程做习题,下半程全体成员到位长光工程师资培养和磨练训骨干第5期先导典礼。

源代码附录

地方的例子均在Windows(VC++6.0)和Linux(GCC4.1.0)上测试评释。上边是测试程序。

#include <iostream>

#include <stdio.h>

using namespace std;

int main()
{
    cout << "sizeof(char)        = " << sizeof(char) << endl;
    cout << "sizeof(short)       = " << sizeof(short) << endl;
    cout << "sizeof(int)         = " << sizeof(int) << endl;
    cout << "sizeof(long)        = " << sizeof(long) << endl;
    cout << "sizeof(float)       = " << sizeof(float) << endl;
    cout << "sizeof(double)      = " << sizeof(double) << endl;
    cout << "sizeof(long long)   = " << sizeof(long long) << endl;
    cout << "sizeof(long double) = " << sizeof(long double) << endl << endl;    

    // 例子1
    {
        struct my_struct 
        { 
            char a; 
            long double b; 
        };
        cout << "exapmle-1: sizeof(my_struct) = " << sizeof(my_struct) << endl;

        struct my_struct data;

        printf("my_struct->a: %u\nmy_struct->b: %u\n\n", &data.a, &data.b);
    }

    // 例子2
    {
        #pragma pack(2) 
        struct my_struct 
        { 
            char a; 
            long double b; 
        }; 

        #pragma pack()
        struct my_struct data;

        cout << "exapmle-2: sizeof(my_struct) = " << sizeof(my_struct) << endl;

        printf("my_struct->a: %u\nmy_struct->b: %u\n\n", &data.a, &data.b);
    }

    // 例子3
    {
        struct my_struct 
        { 
            char a; 
            double b; 
            char c; 
        }; 

        struct my_struct data;

        cout << "exapmle-3: sizeof(my_struct) = " << sizeof(my_struct) << endl;

        printf("my_struct->a: %u\nmy_struct->b: %u\nmy_struct->c: %u\n\n", &data.a, &data.b, &data.c);
    }

    // 例子4
    {
        struct my_struct 
        {  
            char a[11];  
            int b;  
            char c;  
        };

        cout << "example-4: sizeof(my_struct) = " << sizeof(struct my_struct) << endl;

        struct my_struct data;
        printf("my_struct->a: %u\nmy_struct->b: %u\nmy_struct->c: %u\n\n", &data, &data.b, &data.c);
    }

    // 例子5 
    {
        struct my_test 
        { 
            int my_test_a; 
            char my_test_b; 
        }; 

        struct my_struct 
        { 
            struct my_test a; 
            double my_struct_a; 
            int my_struct_b; 
            char my_struct_c; 
        }; 
        cout << "example-5: sizeof(my_struct) = " << sizeof(struct my_struct) << endl;

        struct my_struct data;
        printf("my_struct->my_test_a  : %u\n"
            "my_struct->my_test_b  : %u\n"
            "my_struct->my_struct_a: %u\n"
            "my_struct->my_struct_b: %u\n"
            "my_struct->my_struct_c: %u\n", &data.a.my_test_a, &data.a.my_test_b, 
            &data.my_struct_a, &data.my_struct_b, &data.my_struct_c);
    }

    return 0;
}

实施结果

//Linux localhost 3.4.6-2.10-desktop #1 SMP PREEMPT Thu Jul 28 19:20:26 UTC 2012 (641c197) x86_64 x86_64 x86_64 GNU/Linux
sizeof(char)        = 1
sizeof(short)       = 2
sizeof(int)         = 4
sizeof(long)        = 8
sizeof(float)       = 4
sizeof(double)      = 8
sizeof(long long)   = 8
sizeof(long double) = 16

exapmle-1: sizeof(my_struct) = 32
my_struct->a: 2163695552
my_struct->b: 2163695568

exapmle-2: sizeof(my_struct) = 18
my_struct->a: 2163695680
my_struct->b: 2163695682

exapmle-3: sizeof(my_struct) = 24
my_struct->a: 2163695648
my_struct->b: 2163695656
my_struct->c: 2163695664

example-4: sizeof(my_struct) = 20
my_struct->a: 2163695616
my_struct->b: 2163695628
my_struct->c: 2163695632

example-5: sizeof(my_struct) = 24
my_struct->my_test_a  : 2163695584
my_struct->my_test_b  : 2163695588
my_struct->my_struct_a: 2163695592
my_struct->my_struct_b: 2163695600
my_struct->my_struct_c: 2163695604

//Linux localhost 3.4.6-2.10-desktop #1 SMP PREEMPT Thu Jul 26 09:36:26 UTC 2012 (641c197) i686 i686 i386 GNU/Linux
sizeof(char)        = 1
sizeof(short)       = 2
sizeof(int)         = 4
sizeof(long)        = 4
sizeof(float)       = 4
sizeof(double)      = 8
sizeof(long long)   = 8
sizeof(long double) = 12

exapmle-1: sizeof(my_struct) = 16
my_struct->a: 3213889904
my_struct->b: 3213889908

exapmle-2: sizeof(my_struct) = 14
my_struct->a: 3213889890
my_struct->b: 3213889892

exapmle-3: sizeof(my_struct) = 16
my_struct->a: 3213889872
my_struct->b: 3213889876
my_struct->c: 3213889884

example-4: sizeof(my_struct) = 20
my_struct->a: 3213889852
my_struct->b: 3213889864
my_struct->c: 3213889868

example-5: sizeof(my_struct) = 24
my_struct->my_test_a  : 3213889828
my_struct->my_test_b  : 3213889832
my_struct->my_struct_a: 3213889836
my_struct->my_struct_b: 3213889844
my_struct->my_struct_c: 3213889848

//CYGWIN_NT-6.1 motadou-PC 1.7.20(0.266/5/3) 2013-06-07 11:11 i686 Cygwin
sizeof(char)        = 1
sizeof(short)       = 2
sizeof(int)         = 4
sizeof(long)        = 4
sizeof(float)       = 4
sizeof(double)      = 8
sizeof(long long)   = 8
sizeof(long double) = 12

exapmle-1: sizeof(my_struct) = 16
my_struct->a: 2272336
my_struct->b: 2272340

exapmle-2: sizeof(my_struct) = 14
my_struct->a: 2272322
my_struct->b: 2272324

exapmle-3: sizeof(my_struct) = 24
my_struct->a: 2272296
my_struct->b: 2272304
my_struct->c: 2272312

example-4: sizeof(my_struct) = 20
my_struct->a: 2272276
my_struct->b: 2272288
my_struct->c: 2272292

example-5: sizeof(my_struct) = 24
my_struct->my_test_a  : 2272248
my_struct->my_test_b  : 2272252
my_struct->my_struct_a: 2272256
my_struct->my_struct_b: 2272264
my_struct->my_struct_c: 2272268

相关文章

发表评论

电子邮件地址不会被公开。 必填项已用*标注

*
*
Website