首页 > 试题广场 > 在64位编译器下用sizeof(struct A)计算出的大小是多少
[单选题]
有一个如下的结构体:
struct A{
 long a1;
 short a2;
 int a3;
 int *a4;
};
请问在64位编译器下用sizeof(struct A)计算出的大小是多少?
  • 24
  • 28
  • 16
  • 18

26个回答

添加回答
推荐
A
1.什么是内存对
   查看全部
编辑于 2016-01-13 12:34:28 回复(10)
第一个,8字节
第二个,2字节,加起来是10,对齐到12
第三个,4字节,加起来是16
第四个,8字节,加起来是24
 所以一共是24字节
多看看就背住了:
32位编译器:32位系统下指针占用4字节
      char :1个字节
      char*(即指针变量): 4个字节(32位的寻址空间是2^32, 即32个bit,也就是4个字节。同理64位编译器)
      short int : 2个字节
      int:  4个字节
      unsigned int : 4个字节
      float:  4个字节
      double:   8个字节
      long:   4个字节
      long long:  8个字节
      unsigned long:  4个字节
64位编译器:64位系统下指针占用8字节
      char :1个字节
      char*(即指针变量): 8个字节
      short int : 2个字节
      int:  4个字节
      unsigned int : 4个字节
      float:  4个字节
      double:   8个字节
      long:   8个字节
      long long:  8个字节
      unsigned long:  8个字节

编辑于 2017-05-09 15:23:33 回复(11)
Win64下:long 8字节、short 2字节、int 4字节、int* 8字节,C++中内存对齐,按最大长度对齐:8+(2+4+2(补齐2字节))+8 = 24字节
发表于 2015-09-08 20:28:05 回复(14)
预备知识:基本类型占用字节
在32位操作系统和64位操作系统上,基本数据类型分别占多少字节呢?

32位操作系统:

char : 1    int :4    short : 2    unsigned int : 4    long : 4    unsigned long : 4    long long : 8     float : 4    double : 8    指针 : 4

64位操作系统

char : 1    int :4    short : 2    unsigned int : 4    long : 8    unsigned long : 8    long long : 8     float : 4    double : 8    指针 : 8

内存对齐:
成员对齐有一个重要的条件,即每个成员按自己的方式对齐。其对齐的规则是:每个成员按其类型的对齐参数(通常是这个类型的大小)和指定对齐参数(这里默认是8字节)中较小的一个对齐。并且结构的长度必须为所用过的所有对齐参数的整数倍。不够就补空字节。

举例:

复制代码
struct t{
    long a;
    short b;
    int c;
    int *d; 
    char e;
}
复制代码
 

在64位操作系统中的大小。

分析:

按照声明的顺序一个一个分配内存空间。

首先 long 型变量a,在64位地址空间中,long型占8个字节,所以按照上面的对齐条件,这个成员应该按照对其参数 min(sizeof(long), 8) = 8字节来对齐,所以把这个成员存放在 0~7 内存单元中。

然后 short型变量b,在64位地址空间中,short型占2个字节,所以按照上面的对齐条件,这个成员应该按照对其参数 min(sizeof(short), 8) = 2字节来对齐,所以把这个成员存放在 8~9 内存单元中。

然后 int型变量c,在64位地址空间中,int型占4个字节,所以按照上面的对齐条件,这个成员应该按照对其参数 min(sizeof(int), 8) = 4字节来对齐,所以把这个成员存放在 12~15 内存单元中(10,11单元都不能被4整除)。

然后 int*型变量d,在64位地址空间中,指针型占8个字节,所以按照上面的对齐条件,这个成员应该按照对其参数 min(sizeof(int*), 8) = 8字节来对齐,所以把这个成员存放在 16~23 内存单元中。

然后 char型变量e,在64位地址空间中,char型占1个字节,所以按照上面的对齐条件,这个成员应该按照对其参数 min(sizeof(char), 8) = 1字节来对齐,所以把这个成员存放在 24 内存单元中。

然后整个结构体的长度必须为所有对齐参数的整数倍,当前长度为25,不是所有对齐参数整数倍,必须调整为32,才是所有参数整数倍。

所以这个结构体的长度为32。


如果结构体中出现子结构体怎么办?我们在确定子结构体的对齐参数时,应该就是它的所有成员使用的对齐参数中最大的一个。

举例:

复制代码
struct t{
    char a;
    int b;
};
struct s{
   char c;
   struct t d;
   char e;
};
复制代码
在32位操作系统下的长度。

首先确定t的大小为8,它的所有成员使用的对齐参数最大为4。

再考察s:

首先 char 型变量c,在32位地址空间中,char型占1个字节,所以按照上面的对齐条件,这个成员应该按照对其参数 min(sizeof(char), 8) = 1字节来对齐,所以把这个成员存放在 0 内存单元中。

然后 struct t型变量d,在32位地址空间中,struct t占8个字节,所以按照上面的对齐条件,这个成员应该按照对其参数 4 字节来对齐,所以把这个成员存放在 4~11 内存单元中。

然后 char型变量e,在32位地址空间中,char型占1个字节,所以按照上面的对齐条件,这个成员应该按照对其参数 min(sizeof(char), 8) = 1字节来对齐,所以把这个成员存放在 12 内存单元中。

然后整个结构体的长度必须为所有对齐参数的整数倍,当前长度为13,不是所有对齐参数整数倍,必须调整为16,才是所有参数整数倍。

所以此结构体大小为16.
发表于 2016-03-20 15:15:42 回复(1)
short 2字节对齐,int 4 ,long 8 ,int*  8. 对齐是指各成员选择 是自身倍数的地址存放
所以,地址存储为:
0-7 long ,
8-9 short ,10不是4的整数倍,int 会存放在12的位置对齐,
12-15 int ,
 16-23 int* .总大小为24,满足8的整数倍,不需要补齐。最后大小为24
发表于 2015-09-09 09:41:03 回复(0)
字符长度    当前可用序号                下次可用序号
8                 0                                           8
2                 8                                           10
4               12(4的整数倍10+2)             16
4                20                                           结尾为20不是最大字符long长度8的整数倍(加4)调整为 24
发表于 2015-09-08 16:18:24 回复(3)
structA{
 longa1;
 shorta2;
 inta3;
 int*a4;
};
32位与64位字节有变化是只有指针变量、long、unsigned long:
                             32位       64位
-------------------------------------------
指针变量                 4             8
long                        4             8
unsigned long         4             8

下面每个小方框代表一个字节:(有下划线表示有内容,没有下划线表示会被自动补充)
口口口口 口口口口    // long a1: 占满了第一行8个字节
口口 口口口口  口口   // short a2 占了第二行前两个字节,紧接着int a3 顺序占了第二行第3~6这四个字节,第7、8个字节由系统自动补齐;
口口口口  口口口口    // int *a4: 占满了第三行8个字节
因此:总共3*8 = 24个字节
发表于 2016-06-27 16:36:18 回复(2)
win10+vs2015 64位编译器的输出结果是24,但是long占4位,所以上面很多答案虽然看起来有道理,其实不全对,部分有误导,应该是(4+2+2)+(4+4)+8=24. 不要人云亦云,实践是检验真理的唯一标准。
发表于 2017-03-08 18:18:46 回复(1)
Win64下:long 8字节、short 2字节、int 4字节、int* 8字节,C++中内存对齐,按最大长度对齐:8+(2+4+2(补齐2字节))+8 = 24字节
发表于 2015-11-03 22:11:02 回复(0)
内存对齐的3大规则:
  1. 对于结构体的各个成员,第一个成员的偏移量是0,排列在后面的成员其当前偏移量必须是当前成员类型的整数倍
  2. 结构体内所有数据成员各自内存对齐后,结构体本身还要进行一次内存对齐,保证整个结构体占用内存大小是结构体内最大数据成员的最小整数倍
  3. 如程序中有#pragma pack(n)预编译指令,则所有成员对齐以n字节为准(即偏移量是n的整数倍),不再考虑当前类型以及最大结构体内类型
发表于 2017-09-13 12:09:19 回复(0)
发表于 2016-02-25 20:02:07 回复(0)
24
4
2
4
8
所以:4+2+2(补齐2)+4+4(补齐4)+8=24

发表于 2015-09-09 10:42:31 回复(0)
C++中对齐的问题。很常见。。
发表于 2015-09-08 16:23:27 回复(0)
short 与后面int内存对齐所以也是4最后是20但是要最大内存的整数倍最大long8字节所以加4是24是8的整数倍
发表于 2018-08-28 10:18:43 回复(0)
64位系统,long 8,long long 8,unsigned long 8,指针变量size8,对齐方式最小为8位,结构体中以成员变量最长为对齐方式。如double 8
发表于 2017-12-19 11:23:49 回复(0)
结构体所占用的内存与其成员在结构体中的声明顺序有关,其成员的内存对齐规则如下: (1)每个成员分别按自己的对齐字节数和PPB(指定的对齐字节数,32位机默认为4)两个字节数最小的那个对齐,这样可以最小化长度。如在32bit的机器上,int的大小为4,因此int存储的位置都是4的整数倍的位置开始存储。 (2)复杂类型(如结构)的默认对齐方式是它最长的成员的对齐方式,这样在成员是复杂类型时,结构体数组的时候,可以最小化长度。 (3)结构体对齐后的长度必须是成员中最大的对齐参数(PPB)的整数倍,这样在处理数组时可以保证每一项都边界对齐。  (4)结构体作为数据成员的对齐规则:在一个struct中包含另一个struct,内部struct应该以它的最大数据成员大小的整数倍开始存储。如 struct A 中包含 struct B, struct B 中包含数据成员 char, int, double,则 struct B 应该以sizeof(double)=8的整数倍为起始地址。 64位系统指针8字节
编辑于 2017-09-06 07:26:35 回复(0)

32位操作系统

char :1个字节(固定)

*(即指针变量): 4个字节(32位机的寻址空间是4个字节。同理64位编译器)(变化*)

short int : 2个字节(固定)

int: 4个字节(固定)

unsigned int : 4个字节(固定)

float: 4个字节(固定)

double: 8个字节(固定)

long: 4个字节

unsigned long: 4个字节(变化*,其实就是寻址控件的地址长度数值)

long long: 8个字节(固定)


64位操作系统

char :1个字节(固定)

*(即指针变量): 8个字节

short int : 2个字节(固定)

int: 4个字节(固定)

unsigned int : 4个字节(固定)

float: 4个字节(固定)

double: 8个字节(固定)

long: 8个字节

unsigned long: 8个字节(变化*其实就是寻址控件的地址长度数值)

long long: 8个字节(固定)
 

除了*与long随操作系统子长变化而变化外,其他的都固定不变(32位和64相比)

发表于 2017-07-05 09:35:53 回复(0)
第一个,8字节
第二个,2字节,加起来是10,对齐到12
第三个,4字节,加起来是16
第四个,8字节,加起来是24
 所以一共是24字节
多看看就背住了:
32位编译器:32位系统下指针占用4字节
      char:1个字节
      char*(即指针变量): 4个字节(32位的寻址空间是2^32, 即32个bit,也就是4个字节。同理64位编译器)
      shortint: 2个字节
      int:  4个字节
      unsigned int: 4个字节
      float:  4个字节
      double:   8个字节
      long:   4个字节
      longlong:  8个字节
      unsigned long:  4个字节
64位编译器:64位系统下指针占用8字节
      char:1个字节
      char*(即指针变量): 8个字节
      shortint: 2个字节
      int:  4个字节
      unsigned int: 4个字节
      float:  4个字节
      double:   8个字节
      long:   8个字节
      longlong:  8个字节
      unsigned long:  8个字节

发表于 2017-06-06 21:36:42 回复(0)
第一个,8字节
第二个,2字节,加起来是10,对齐到12
第三个,4字节,加起来是16
第四个,8字节,加起来是24
 所以一共是24字节
多看看就背住了:
32位编译器:32位系统下指针占用4字节
      char:1个字节
      char*(即指针变量): 4个字节(32位的寻址空间是2^32, 即32个bit,也就是4个字节。同理64位编译器)
      shortint: 2个字节
      int:  4个字节
      unsignedint: 4个字节
      float:  4个字节
      double:   8个字节
      long:   4个字节
      longlong:  8个字节
      unsignedlong:  4个字节
64位编译器:64位系统下指针占用8字节
      char:1个字节
      char*(即指针变量): 8个字节
      shortint: 2个字节
      int:  4个字节
      unsignedint: 4个字节
      float:  4个字节
      double:   8个字节
      long:   8个字节
      longlong:  8个字节
      unsignedlong:  8个字节
发表于 2017-05-31 19:53:28 回复(0)
64位指针8个字节
发表于 2017-05-14 18:43:06 回复(0)
应该是long(8)+(short(2+2)+int(4))+int(4+4)=8+8+8=24
发表于 2016-10-12 15:14:11 回复(0)

扫一扫,把题目装进口袋

牛客网,程序员必备求职神器

扫描二维码,进入QQ群

扫描二维码,关注牛客网公众号

  • 公司地址:北京市朝阳区大屯路东金泉时代3-2708北京牛客科技有限公司
  • 联系方式:010-60728802(电话) admin@nowcoder.com
  • 牛客科技©2018 All rights reserved
  • 京ICP备14055008号-4
  • 京公网安备 11010502036488号