sizeof_sizeof用法 - CSDN
sizeof 订阅
在 Pascal 语言中,sizeof() 是一种内存容量度量函数,功能是返回一个变量或者类型的大小(以字节为单位);在 C 语言中,sizeof() 是一个判断数据类型或者表达式长度的运算符。在Pascal 语言与C语言中,对 sizeof() 的处理都是在编译阶段进行。 展开全文
在 Pascal 语言中,sizeof() 是一种内存容量度量函数,功能是返回一个变量或者类型的大小(以字节为单位);在 C 语言中,sizeof() 是一个判断数据类型或者表达式长度的运算符。在Pascal 语言与C语言中,对 sizeof() 的处理都是在编译阶段进行。
信息
类    型
计算机专用名称
过    程
字节数的计算在程序编译时进行
作    用
判断数据类型长度符的关键字
返回值
内存所占字节数
外文名
sizeof
定    义
是C/C++中的一个操作符
sizeofPascal中的用法
输出:如果longint改为Integer,也输出(Pascal中longInt和Integer都是4字节):
收起全文
精华内容
参与话题
  • sizeof()计算方法 c/c++

    千次阅读 多人点赞 2013-10-17 20:17:39
    sizeof 是计算分配内存的大小 int 整型 占4个字节 int i,sizeof(i)=4;int a1[9],sizeof(a1)=4*9=36; double 浮点型占8个字节 double b,sizeof(b)=8;double b[3],sizeof(b)=8*3=24; char 字符 占1个字节...
    sizeof 是计算分配内存的大小
    int    整型  占4个字节 int i,sizeof(i)=4;int a1[9],sizeof(a1)=4*9=36;
    double 浮点型占8个字节 double b,sizeof(b)=8;double b[3],sizeof(b)=8*3=24;
    char   字符  占1个字节 char a,sizeof(a)=1;char b1[9],sizeof(b1)=9; char b2[]="abcde",sizeof(b2)=5+1=6;
    指针类型 指针存的是地址 地址占4个字节 int *a,char* a,double *a,char *a="abcdf" 的 sizeof(a)均为4
    结构体       占内存计算方法为 结构体中占大于等于最大空间元素的整数倍(最接近)
    struct A
    {
    int a;
    double b;
    int c;
    char d;
    char e;
    };
    sizeof(A)=4+8+4+1+1<=24;
    展开全文
  • C语言 sizeof函数详解

    万次阅读 多人点赞 2018-05-17 10:10:26
    from:https://blog.csdn.net/wzy198852/article/details/7246836sizeof,一个其貌不扬的家伙,引无数菜鸟竟折腰,小虾我当初也没少犯迷糊,秉着“辛苦我一个,幸福千万人”的伟大思想,我决定将其尽可能详细的总结...

    from:https://blog.csdn.net/wzy198852/article/details/7246836

    sizeof,一个其貌不扬的家伙,引无数菜鸟竟折腰,小虾我当初也没少犯迷糊,秉着“

    辛苦我一个,幸福千万人”的伟大思想,我决定将其尽可能详细的总结一下。
    但当我总结的时候才发现,这个问题既可以简单,又可以复杂,所以本文有的地方并不
    适合初学者,甚至都没有必要大作文章。但如果你想“知其然,更知其所以然”的话,
    那么这篇文章对你或许有所帮助。
    菜鸟我对C++的掌握尚未深入,其中不乏错误,欢迎各位指正啊

    1. 定义:
    sizeof是何方神圣sizeof乃C/C++中的一个操作符(operator)是也,简单的说其作
    用就是返回一个对象或者类型所占的内存字节数。
    MSDN上的解释为:
    The sizeof keyword gives the amount of storage, in bytes, associated with a
    variable or a type (including aggregate types). 
    This keyword returns a value of type size_t.
    其返回值类型为size_t,在头文件stddef.h中定义。这是一个依赖于编译系统的值,一
    般定义为
    typedef unsigned int size_t;
    世上编译器林林总总,但作为一个规范,它们都会保证char、signed char和unsigned
    char的sizeof值为1,毕竟char是我们编程能用的最小数据类型。
    2. 语法:
    sizeof有三种语法形式,如下:
    1) sizeof( object ); // sizeof( 对象 );
    2) sizeof( type_name ); // sizeof( 类型 );
    3) sizeof object; // sizeof 对象;
    所以,
    int i;
    sizeof( i ); // ok
    sizeof i; // ok
    sizeof( int ); // ok
    sizeof int; // error
    既然写法3可以用写法1代替,为求形式统一以及减少我们大脑的负担,第3种写法,忘
    掉它吧!
    实际上,sizeof计算对象的大小也是转换成对对象类型的计算,也就是说,同种类型的
    不同对象其sizeof值都是一致的。这里,对象可以进一步延伸至表达式,即sizeof可以
    对一个表达式求值,编译器根据表达式的最终结果类型来确定大小,一般不会对表达式
    进行计算。如:
    sizeof( 2 );// 2的类型为int,所以等价于 sizeof( int );
    sizeof( 2 + 3.14 ); // 3.14的类型为double,2也会被提升成double类型,所以等价
    于 sizeof( double );
    sizeof也可以对一个函数调用求值,其结果是函数返回类型的大小,函数并不会被调用
    ,我们来看一个完整的例子:
    char foo()
    {
    printf("foo() has been called./n");
    return 'a';
    }
    int main()
    {
    size_t sz = sizeof( foo() ); // foo() 的返回值类型为char,所以sz = sizeof(
    char ),foo()并不会被调用
    printf("sizeof( foo() ) = %d/n", sz);
    }
    C99标准规定,函数、不能确定类型的表达式以及位域(bit-field)成员不能被计算s
    izeof值,即下面这些写法都是错误的:
    sizeof( foo );// error
    void foo2() { }
    sizeof( foo2() );// error
    struct S
    {
    unsigned int f1 : 1;
    unsigned int f2 : 5;
    unsigned int f3 : 12;
    };
    sizeof( S.f1 );// error
    3. sizeof的常量性
    sizeof的计算发生在编译时刻,所以它可以被当作常量表达式使用,如:
    char ary[ sizeof( int ) * 10 ]; // ok
    最新的C99标准规定sizeof也可以在运行时刻进行计算,如下面的程序在Dev-C++中可以
    正确执行:
    int n;
    n = 10; // n动态赋值
    char ary[n]; // C99也支持数组的动态定义
    printf("%d/n", sizeof(ary)); // ok. 输出10
    但在没有完全实现C99标准的编译器中就行不通了,上面的代码在VC6中就通不过编译。
    所以我们最好还是认为sizeof是在编译期执行的,这样不会带来错误,让程序的可移植
    性强些。
    4. 基本数据类型的sizeof
    这里的基本数据类型指short、int、long、float、double这样的简单内置数据类型,
    由于它们都是和系统相关的,所以在不同的系统下取值可能不同,这务必引起我们的注
    意,尽量不要在这方面给自己程序的移植造成麻烦。
    一般的,在32位编译环境中,sizeof(int)的取值为4。
    5. 指针变量的sizeof
    学过数据结构的你应该知道指针是一个很重要的概念,它记录了另一个对象的地址。既
    然是来存放地址的,那么它当然等于计算机内部地址总线的宽度。所以在32位计算机中
    ,一个指针变量的返回值必定是4(注意结果是以字节为单位),可以预计,在将来的6
    4位系统中指针变量的sizeof结果为8。
    char* pc = "abc";
    int* pi;
    string* ps;
    char** ppc = &pc;
    void (*pf)();// 函数指针
    sizeof( pc ); // 结果为4
    sizeof( pi ); // 结果为4
    sizeof( ps ); // 结果为4
    sizeof( ppc ); // 结果为4
    sizeof( pf );// 结果为4
    指针变量的sizeof值与指针所指的对象没有任何关系,正是由于所有的指针变量所占内
    存大小相等,所以MFC消息处理函数使用两个参数WPARAM、LPARAM就能传递各种复杂的消
    息结构(使用指向结构体的指针)。
    6. 数组的sizeof
    数组的sizeof值等于数组所占用的内存字节数,如:
    char a1[] = "abc";
    int a2[3];
    sizeof( a1 ); // 结果为4,字符 末尾还存在一个NULL终止符
    sizeof( a2 ); // 结果为3*4=12(依赖于int)
    一些朋友刚开始时把sizeof当作了求数组元素的个数,现在,你应该知道这是不对的,
    那么应该怎么求数组元素的个数呢Easy,通常有下面两种写法:
    int c1 = sizeof( a1 ) / sizeof( char ); // 总长度/单个元素的长度
    int c2 = sizeof( a1 ) / sizeof( a1[0] ); // 总长度/第一个元素的长度
    写到这里,提一问,下面的c3,c4值应该是多少呢
    void foo3(char a3[3])
    {
    int c3 = sizeof( a3 ); // c3 == 
    }
    void foo4(char a4[])
    {
    int c4 = sizeof( a4 ); // c4 == 
    }
    也许当你试图回答c4的值时已经意识到c3答错了,是的,c3!=3。这里函数参数a3已不
    再是数组类型,而是蜕变成指针,相当于char* a3,为什么仔细想想就不难明白,我
    们调用函数foo1时,程序会在栈上分配一个大小为3的数组吗不会!数组是“传址”的
    ,调用者只需将实参的地址传递过去,所以a3自然为指针类型(char*),c3的值也就为
    4。
    7. 结构体的sizeof
    这是初学者问得最多的一个问题,所以这里有必要多费点笔墨。让我们先看一个结构体

    struct S1
    {
    char c;
    int i;
    };
    问sizeof(s1)等于多少聪明的你开始思考了,char占1个字节,int占4个字节,那么
    加起来就应该是5。是这样吗你在你机器上试过了吗也许你是对的,但很可能你是错
    的!VC6中按默认设置得到的结果为8。
    Why为什么受伤的总是我
    请不要沮丧,我们来好好琢磨一下sizeof的定义——sizeof的结果等于对象或者类型所
    占的内存字节数,好吧,那就让我们来看看S1的内存分配情况:
    S1 s1 = { 'a', 0xFFFFFFFF };
    定义上面的变量后,加上断点,运行程序,观察s1所在的内存,你发现了什么
    以我的VC6.0为例,s1的地址为0x0012FF78,其数据内容如下:
    0012FF78: 61 CC CC CC FF FF FF FF
    发现了什么怎么中间夹杂了3个字节的CC看看MSDN上的说明:
    When applied to a structure type or variable, sizeof returns the actual siz
    e, which may include padding bytes inserted for alignment.
    原来如此,这就是传说中的字节对齐啊!一个重要的话题出现了。
    为什么需要字节对齐计算机组成原理教导我们这样有助于加快计算机的取数速度,否
    则就得多花指令周期了。为此,编译器默认会对结构体进行处理(实际上其它地方的数
    据变量也是如此),让宽度为2的基本数据类型(short等)都位于能被2整除的地址上,
    让宽度为4的基本数据类型(int等)都位于能被4整除的地址上,以此类推。这样,两个
    数中间就可能需要加入填充字节,所以整个结构体的sizeof值就增长了。
    让我们交换一下S1中char与int的位置:
    struct S2
    {
    int i;
    char c;
    };
    看看sizeof(S2)的结果为多少,怎么还是8再看看内存,原来成员c后面仍然有3个填
    充字节,这又是为什么啊别着急,下面总结规律。

    字节对齐的细节和编译器实现相关,但一般而言,满足三个准则:
    1) 结构体变量的首地址能够被其最宽基本类型成员的大小所整除;
    2) 结构体每个成员相对于结构体首地址的偏移量(offset)都是成员大小的整数倍,
    如有需要编译器会在成员之间加上填充字节(internal adding);
    3) 结构体的总大小为结构体最宽基本类型成员大小的整数倍,如有需要编译器会在最
    末一个成员之后加上填充字节(trailing padding)。
    对于上面的准则,有几点需要说明:
    1) 前面不是说结构体成员的地址是其大小的整数倍,怎么又说到偏移量了呢因为有
    了第1点存在,所以我们就可以只考虑成员的偏移量,这样思考起来简单。想想为什么。

    结构体某个成员相对于结构体首地址的偏移量可以通过宏offsetof()来获得,这个宏也
    在stddef.h中定义,如下:
    #define offsetof(s,m) (size_t)&(((s *)0)->m)
    例如,想要获得S2中c的偏移量,方法为
    size_t pos = offsetof(S2, c);// pos等于4
    2) 基本类型是指前面提到的像char、short、int、float、double这样的内置数据类型
    ,这里所说的“数据宽度”就是指其sizeof的大小。由于结构体的成员可以是复合类型
    ,比如另外一个结构体,所以在寻找最宽基本类型成员时,应当包括复合类型成员的子
    成员,而不是把复合成员看成是一个整体。但在确定复合类型成员的偏移位置时则是将
    复合类型作为整体看待。
    这里叙述起来有点拗口,思考起来也有点挠头,还是让我们看看例子吧(具体数值仍以
    VC6为例,以后不再说明):
    struct S3
    {
    char c1;
    S1 s;
    char c2
    };
    S1的最宽简单成员的类型为int,S3在考虑最宽简单类型成员时是将S1“打散”看的,
    所以S3的最宽简单类型为int,这样,通过S3定义的变量,其存储空间首地址需要被4整
    除,整个sizeof(S3)的值也应该被4整除。
    c1的偏移量为0,s的偏移量呢这时s是一个整体,它作为结构体变量也满足前面三个
    准则,所以其大小为8,偏移量为4,c1与s之间便需要3个填充字节,而c2与s之间就不需
    要了,所以c2的偏移量为12,算上c2的大小为13,13是不能被4整除的,这样末尾还得补
    上3个填充字节。最后得到sizeof(S3)的值为16。
    通过上面的叙述,我们可以得到一个公式:
    结构体的大小等于最后一个成员的偏移量加上其大小再加上末尾的填充字节数目,即:

    sizeof( struct ) = offsetof( last item ) + sizeof( last item ) + sizeof( tr
    ailing padding )

    到这里,朋友们应该对结构体的sizeof有了一个全新的认识,但不要高兴得太早,有
    一个影响sizeof的重要参量还未被提及,那便是编译器的pack指令。它是用来调整结构
    体对齐方式的,不同编译器名称和用法略有不同,VC6中通过#pragma pack实现,也可以
    直接修改/Zp编译开关。#pragma pack的基本用法为:#pragma pack( n ),n为字节对齐
    数,其取值为1、2、4、8、16,默认是8,如果这个值比结构体成员的sizeof值小,那么
    该成员的偏移量应该以此值为准,即是说,结构体成员的偏移量应该取二者的最小值,
    公式如下:
    offsetof( item ) = min( n, sizeof( item ) )
    再看示例:
    #pragma pack(push) // 将当前pack设置压栈保存
    #pragma pack(2)// 必须在结构体定义之前使用
    struct S1
    {
    char c;
    int i;
    };
    struct S3
    {
    char c1;
    S1 s;
    char c2
    };
    #pragma pack(pop) // 恢复先前的pack设置
    计算sizeof(S1)时,min(2, sizeof(i))的值为2,所以i的偏移量为2,加上sizeof(i)
    等于6,能够被2整除,所以整个S1的大小为6。
    同样,对于sizeof(S3),s的偏移量为2,c2的偏移量为8,加上sizeof(c2)等于9,不能
    被2整除,添加一个填充字节,所以sizeof(S3)等于10。
    现在,朋友们可以轻松的出一口气了,:)
    还有一点要注意,“空结构体”(不含数据成员)的大小不为0,而是1。试想一个“不
    占空间”的变量如何被取地址、两个不同的“空结构体”变量又如何得以区分呢于是
    ,“空结构体”变量也得被存储,这样编译器也就只能为其分配一个字节的空间用于占
    位了。如下:
    struct S5 { };
    sizeof( S5 ); // 结果为1

    8. 含位域结构体的sizeof
    前面已经说过,位域成员不能单独被取sizeof值,我们这里要讨论的是含有位域的结构
    体的sizeof,只是考虑到其特殊性而将其专门列了出来。
    C99规定int、unsigned int和bool可以作为位域类型,但编译器几乎都对此作了扩展,
    允许其它类型类型的存在。
    使用位域的主要目的是压缩存储,其大致规则为:
    1) 如果相邻位域字段的类型相同,且其位宽之和小于类型的sizeof大小,则后面的字
    段将紧邻前一个字段存储,直到不能容纳为止;
    2) 如果相邻位域字段的类型相同,但其位宽之和大于类型的sizeof大小,则后面的字
    段将从新的存储单元开始,其偏移量为其类型大小的整数倍;
    3) 如果相邻的位域字段的类型不同,则各编译器的具体实现有差异,VC6采取不压缩方
    式,Dev-C++采取压缩方式;
    4) 如果位域字段之间穿插着非位域字段,则不进行压缩;
    5) 整个结构体的总大小为最宽基本类型成员大小的整数倍。

    还是让我们来看看例子。
    示例1:
    struct BF1
    {
    char f1 : 3;
    char f2 : 4;
    char f3 : 5;
    };
    其内存布局为:
    |_f1__|__f2__|_|____f3___|____|
    |_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|
    0 3 7 8 1316
    位域类型为char,第1个字节仅能容纳下f1和f2,所以f2被压缩到第1个字节中,而f3只
    能从下一个字节开始。因此sizeof(BF1)的结果为2。
    示例2:
    struct BF2
    {
    char f1 : 3;
    short f2 : 4;
    char f3 : 5;
    };
    由于相邻位域类型不同,在VC6中其sizeof为6,在Dev-C++中为2。
    示例3:
    struct BF3
    {
    char f1 : 3;
    char f2;
    char f3 : 5;
    };
    非位域字段穿插在其中,不会产生压缩,在VC6和Dev-C++中得到的大小均为3。
    9. 联合体的sizeof
    结构体在内存组织上是顺序式的,联合体则是重叠式,各成员共享一段内存,所以整个
    联合体的sizeof也就是每个成员sizeof的最大值。结构体的成员也可以是复合类型,这
    里,复合类型成员是被作为整体考虑的。
    所以,下面例子中,U的sizeof值等于sizeof(s)。
    union U
    {
    int i;
    char c;
    S1 s;
    };
    展开全文
  • C语言基础——sizeof的用法总结

    万次阅读 多人点赞 2020-03-16 14:18:57
    sizeof是C语言中保留关键字,也可以认为是一种运算符,单目运算符。常见的使用方式: int a=10; int arr=[1,2,3]; char str[]="hello"; int len_a = sizeof(a); int len_arr = sizeof(arr); int len_str...

    sizeof是C语言中保留关键字,也可以认为是一种运算符,单目运算符。常见的使用方式:

    int a=10;
    int arr=[1,2,3];
    char str[]="hello";
    int len_a = sizeof(a);
    int len_arr = sizeof(arr);
    int len_str = sizeof(str)
    
    printf("len_a=%d,len_arr=%d,len_str=%d\n",len_a,len_arr,len_str)

    看了上面的代码,一般会认为结果是:len_a=1,len_arr=3,len_str=5

    实际上的结果是:len_a=4,len_arr=12,len_str=6

    sizeof还可以这么用:

    printf("len_int=%d,len_short=%d,len_double=%d", sizeof(int), sizeof(short), sizeof(double));

    获取某个数据类型所占用空间的字节数。

    再来看另外一段代码:

    #include<stdio.h>
    
    void main(){
            int a = 10;
    	char b = 'b';
    	short c = 2;
    	long d = 9;
    	float e = 6.29f;
    	double f = 95.0629;
    	int arr[] = { 1,2,3 };
    	char str[] = "hello";
    	double *p=&f;
    	int *i=&a;
    	//分别对各个变量使用sizeof运算
    	printf("a=%d,b=%d,c=%d,d=%d,e=%d,f=%d,arr=%d,str=%d point_p=%d,point_i=%d\n",
    		sizeof(a), sizeof(b), sizeof(c), sizeof(d), sizeof(e), sizeof(f),
    		sizeof(arr), sizeof(str), sizeof(p), sizeof(i));
    
    	system("pause");
    }
    输出的结果是:a=4,b=1,c=2,d=4,e=4,f=8,arr=12,str=6 point_p=4,point_i=4

    看了这些结果,应该也能逆推出来sizeof的含义了吧。

    sizeof实际上是获取了数据在内存中所占用的存储空间,以字节为单位来计数。

    C语言会自动在在双引号""括起来的内容的末尾补上"\0"代表结束,ASCII中的0号位也占用一个字符。

    注意,了解了sizeof的真正含义后。类似如下的代码就很low了。

    int arr[]={1,2,3};
    for(int i=0;i<sizeof(arr);i++){
        printf("%d,",arr[i]);
    }
    除了会输出1,2,3以外,还会输出杂乱无章的数字,但一共是输出12个。
    因为数组的内存是动态分配的,到了元素3以后的元素都是新分配的,并不一定是空。
    因为数组是一片连续的空间,有可能元素3的空间是有数据的,那么C语言会将其读取出来,
    当然是一些没有实际意义的杂乱无章的数字,但你不要想着去操作,否则可能导致数据错乱
    所以有可能你运行好几次,后面的值都不会有变化。
    
    不过改成如下代码,就很精辟了。
    
    int arr[]={1,2,3};
    for(int i=0;i<(sizeof(arr)/sizeof(int));i++){
        printf("%d,",arr[i]);
    }

     

    C/C++中,sizeof()只是运算符号,是编译的时候确定大小的。动态分配是运行过程中得到大小的,也就是说C++中new出来的内存,sizeof都无法统计的,退一步说,即使时new出来的空间也有可能失败,所以sizeof无法统计动态分配的内存大小。

    例如:

    //使用new关键字,在堆区开辟一个int数组
    int* arr = new int[5]{1,2,3,4,5}; 
    //统计一个指针的大小,32位系统指针占4字节,64位系统指针占8字节
    cout << sizeof(arr) << endl;
    //解指针,32位系统下,结果和上面一样,因为arr指针指向的时数组的首元素,int类型占4字节
    cout << sizeof(*arr) << endl;
    

     

    展开全文
  • sizeof()大小总结

    千次阅读 2018-09-19 23:15:03
    sizeof 运算符 查询对象或类型的大小 在需要知道对象的实际大小时使用 语法: sizeof(类型) sizeof 表达式 解释 返回 类型 的对象表示的字节数。 返回当 表达式 求值时所返回的类型的对象表示的字节数。 #...

    sizeof 运算符

    查询对象或类型的大小
    在需要知道对象的实际大小时使用
    语法:

    1. sizeof(类型)
    2. sizeof 表达式

    解释

    1. 返回 类型 的对象表示的字节数。
    2. 返回当 表达式 求值时所返回的类型的对象表示的字节数。
    #include <iostream>
    class A
    {
    };
    int main()
    {
    	A a;
        std::cout<< sizeof a <<endl; //OK 1
        //std::cout<< sizeof A <<endl; //Error 可以是变量,但是不能是类型或者类,A是类
        int Int1;
        std::cout << sizeof Int1 << endl;
        //std::cout << sizeof int << endl; //Error 可以是变量,但是不能是类型或者类,int是类型
        std::cout << sizeof(float)<<endl; //OK  4,32编译器,float大小是4个字节
        std::cout << sizeof(bool) <<endl;//OK 1,bool虽然只有一位,但是字节对齐,也是1一个字节
        std::cout << sizeof(long) <<endl;//OK 4
        std::cout << sizeof(long long) <<endl;//OK 8
        return 0;
    }
    
    int i = 0;
    A) sizeof(int); B)sizeof(i); C) sizeof i; D)sizeof int;
    

    通过对比之后,除了D,其他都是正确的。所以如果可以的话,我们最好使用sizeof();

    1.基本数据类型的sizeof

    基本类型包括:bool ,char, short, int, long ,long long,float,double
    32位编译器
    指针都是4位

    数据类型 大小
    bool 1
    char 1
    short 2
    int 4
    long 4
    long long 8
    float 4
    double 8

    64位编译器
    指针都是8位

    数据类型 大小
    bool 1
    char 1
    short 2
    int 4
    long 8
    long long 8
    float 4
    double 8

    2.结构体

    结构体的sizeof涉及到字节对齐问题
    注意:空结构体(不含数据成员)的sizeof值为1。这个和类是一样的。

    struct A  
    {  
        char a;  
        int b;  
    };  
    sizeof(A); //值为8,字节对齐,在char之后会填充3个字节。  
      
    struct B
    {  
        int b;  
        char a;  
    };  
    sizeof(B); //值为8,字节对齐,在char之后会填充3个字节。  
      
    struct C
    {  
    };  
    sizeof(C); //值为1,空结构体也占内存
    

    3.联合体

    联合体是共享一段内存,其中最大的变量大小。
    因为long long和double都是8个字节。

    其中char str[21]本来最大内存是21个字节,但是是4字节对齐,所以需要补齐后面3个字节,所以大小是24字节

    union u
    {
        bool b;
        short s;
        int i;
        float f;
        double d;
        long l;
        long long ll;
        char str[21];
    };
    cout <<sizeof(u)<<endl; //值为24
    

    4.数组大小

        char str[]="abcd";//大小是5,因为后面还有一个'\0',所以要+1
        char *pStr="abcd";//大小是4,32系统,这里pStr是指针
    
    void funA(char a[5])
    {
    	int len = sizeof(a);// len = 4,这函数里面,a不是数组类型,而是指针,所以大小是4
    }
    
    void funB(char a[])
    {
    	int len = sizeof(a);// len = 4,这函数里面,a不是数组类型,而是指针,所以大小是4
    }
    

    5.指针

    指针是用来记录另一个对象的地址,所以指针的内存大小当然就等于计算机内部地址总线的宽度。
    在32位编译器中,一个指针变量的返回值必定是4。
    指针变量的sizeof值与指针所指的对象没有任何关系。

    char* str="123";
    cout<<sizeof(str)<<endl;//4//这里是一个变量的大小
    cout<<sizeof(*str)<<endl;//1,这里指的是一个char的大小
    char *c[22];
    cout<<sizeof(c)<<endl;//88,因为一个指针大小是4,22个指针就是88,所以大小是88
    double *d; 
    cout<<sizeof(d)<<endl;//4,这里是指针的大小
    cout<<sizeof(*d)<<endl;//8,这里是一个double变量的大小
    long long **L;
    cout<<sizeof(L)<<endl;//4,指针大小
    cout<<sizeof(*L)<<endl;//4,指针大小
     cout<<sizeof(**L)<<endl;//8,long long 大小
    void (*pf)();//这是一个函数指针
    cout<<sizeof(pf)<<endl;//4,指针大小
    

    6.函数

    int fun()
    {
        return 9;
    }
    double funD()
    {
        return 1.1;
    }
    void funV()
    {
    
    }
    
    int test06()
    {
        cout<<sizeof(fun())<<endl; //4,相当于sizeof(int)
        cout<<sizeof(int)<<endl;//4
        cout<<sizeof(funD())<<endl; //8,相当于sizeof(double)
        cout<<sizeof(double)<<endl;//8
        cout<<sizeof(funV())<<endl;//1,相当于sizeof(void)
        cout<<sizeof(void)<<endl;//1
        void (*fv)();
        fv = funV;
        cout<<sizeof(fv)<<endl;//4,指针大小
    	double (*df)(double,double);
        df = funD;
        cout<<df(1.3,9.1)<<endl;//10.4
        cout<<sizeof(df)<<endl;//4,指针大小
        return 0;
    }
    

    7.类

    注意不要说类的大小,是类的对象的大小.

    首先,类的大小是什么?确切的说,类只是一个类型定义,它是没有大小可言的。 用sizeof运算符对一个类型名操作,得到的是具有该类型实体的大小。

    如果 Class A; A obj; 那么sizeof(A)==sizeof(obj) 那么sizeof(A)的大小和成员的大小总和是什么关系呢,很简单,一个对象的大小大于等于所有非静态成员大小的总和。

    空类

    #include <iostream>
    using namespace std;
    class A
    {
    
    };
    class B
    {
    public:
        void fun(){}
        B(){}
        ~B(){}
    };
    class C
    {
    public:
        C(){}
        virtual ~C(){}
        virtual void fun(){}
    };
    
    
    int main()
    {
        cout<<sizeof(A)<<endl;//1,类的大小不为0,空类大小为1
        cout<<sizeof(B)<<endl;//1,类中普通函数没有大小
        cout<<sizeof(C)<<endl;//4,类C中包含虚函数,编译器会在给类中生成一个虚函数表,
        					//并在该类型的每一个实例中添加一个指向虚函数表的指针。
      						  //在32位的机器上,一个指针占4个字节的空间,因此sizeof(C)是4,
      						  //而且不论有多少个虚函数,都是一个指针大小
    
    
        return 0;
    }
    
    
    struct S
    {
        char c;
    };
    
    class C
    {
    public:
        C(){}
        virtual ~C(){}
        virtual void fun(){}
    };
    class D {
    
        char ch;
    
        void func() { }
    
    };
    
    class E {
    
        char ch1; //占用1字节
    
        char ch2; //占用1字节
    
        virtual void func() { }
    
    };
    class E_2 {
    
        char ch1; //占用1字节
    
        int i1; //4
    
        char ch2; //占用1字节
    
        virtual void func() { }
    
    };
    class F {
    
         float f;
    
        virtual void func() { }
    
    };
    
    int test02()
    {
        cout<<sizeof(D)<<endl;//1
        cout<<sizeof(E)<<endl;//8
        cout<<sizeof(E_2)<<endl;//16
        cout<<sizeof(F)<<endl;//8
        cout<<sizeof(S)<<endl;//1
        return 0;
    }
    

    这里我们发现,如果只有一个字节,那么就不用对齐什么的了,如果大小不是1,那么我们就要注意字节对齐,如类E,和类E_2,在两个char型之间,加了一个int型,就导致大小变成了16,因为第一个char型虽然只有1位,但是为了字节对齐,就变成了4字节,同样的是后面一个char型,也是一样,所以就变成了4+4+4+4 = 16.

    求含有静态数据成员的类的大小

    class T {
    private:
        int data = 2;
        static char c;
    };
    cout<<sizeof(T)<<endl; //4
    

    求继承类的大小

    #include <iostream>
    using namespace std;
    class A {};
    class B {};
    class C {char c;};
    class D {int c;};
    class C_1{char c;};
    class E:public A{};
    class F:public A,public B,public C{};
    class G:public A,public B,public D{};
    class H:public C,public D,public C_1{};
    class H_1:public C,public C_1,public D{};
    class H_2:public C,public C_1,public D,public B,public A{};
    int main()
    {
        cout<<sizeof(E)<<endl; //1
        cout<<sizeof(F)<<endl; //1//继承一个或者多个空类,派生类还是空类,大小还是为1
        cout<<sizeof(G)<<endl; //4
        cout<<sizeof(H)<<endl; //12,按照父类的顺序来字节对齐,
        cout<<sizeof(H_1)<<endl; //8,按照父类的顺序来字节对齐
        cout<<sizeof(H_2)<<endl;//8,最后B,A两个父类是空类,但是H_2类前面几个父类不是空类,所以就大小还是8
        return 0;
    }
    
    

    小结类的大小

    1.为类的非静态成员数据的类型大小之和.
    
    2.由编译器额外加入的成员变量的大小,用来支持语言的某些特性(如:指向虚函数的指针).
    
    3.为了优化存取效率,进行的边缘调整(对齐).
    
    4 与类中的构造函数,析构函数以及其他的成员函数无关.
    
    
    展开全文
  • sizeof()详解

    千次阅读 2016-10-19 16:52:41
    sizeof的结果(以下结果都是在Linux v2.6 gcc v4获取)  sizeof操作符的结果类型是size_t  它在头文件中定义为: typedef unsigned int size_t;  该类型保证能容纳实现所建立的最大对象的字节大小.  1、ANSI...
  • sizeof

    2019-01-31 20:08:52
    1、什么是sizeof  首先看一下sizeof在msdn上的定义:  The sizeof keyword gives the amount of storage, in bytes, associated with a variable or a type (including aggregate types). This keyword returns ...
  • C语言中sizeof()的用法

    万次阅读 多人点赞 2018-12-19 09:22:18
    只要参加软件研发的笔试(C/C++)几乎都会涉及到sizeof()的用法,我昨天也遇到了,有的也会,但是真正sizeof()的核心还是没有领会,今天上网,无聊中就看到了详细的sizeof()的阐述,现在分享给大家。 -------...
  • sizeof运算符详细总结

    千次阅读 2016-03-09 10:38:28
    简介   sizeof是C/C++中的关键字,它是一个运算符,其作用是取得一个对象(数据类型或者数据对象)的长度(即占用内存的大小,以byte为单位)。其中类型包含基本数据类型(不包括void)、用户自定义类型(结构体、类)、...
  • sizeof(结构体)的分析

    千次阅读 2019-03-15 09:52:46
    一、为什么结构体计算这么乱? 答案是字节对齐,计算机存储系统中以Byte为单位存储数据,不同数据类型所占的空间不同,如:整型(int)数据占4个字节,字符型(char)数据占一个字 节, 短整型(short)数据占两个...
  • sizeof全面总结——举一反三详细介绍sizeof(结构体)

    万次阅读 多人点赞 2020-08-08 23:17:27
    字节 short int float long *(地址) double long long 32位 2 4 ... ...
  • C语言中的sizeof用法

    万次阅读 2015-07-31 17:12:01
    C语言中的sizeof是一个很有意思的关键字,经常有人用不对,搞不清不是什么。我以前也有用错的时候,现在写一写,也算是提醒一下自己吧。反正现在来看,还在搞sizeof是什么意思,怎么用正确,还是有点搞笑,都经常用...
  • c 语言中的sizeof(数组名)和sizeof(指针)

    万次阅读 多人点赞 2018-04-08 17:26:40
    sizeof(数组名):返回数组所有元素占有的内存空间字节数。 sizeof(指针) :返回计算机系统的地址字节数,如果是32位系统,返回4,16位系统返回2。
  • sizeof(数组名)与sizeof(*数组名) 举例 #include int main() { int a[5]={1,2,3,4,5}; printf("sizeof数组名=%d\n",sizeof(a)); printf("sizeof *数组名=%d\n",sizeof(*a)); } 运行结果 sizeof数组名=20 sizeof *...
  • 关于 n=sizeof(a)/sizeof(int)的含义

    千次阅读 2018-05-31 20:41:04
    sizeof() 是运算符,计算小括号里的变量占内存多少单元,计量单位是字节数。sizeof(int); 计算一个 int 型 变量占内存多少单元。sizeof(a) 计算 整型数组里元素 占用内存多少单元。显然,整型数组元素 占用内存为 x*...
  • 数组求长度,用sizeof(数组名)

    万次阅读 2018-05-19 11:11:08
    sizeof(arr) = 16;char arr[] = "abc";sizeof(arr) = 4;strlen(arr)=3char arr[] = {'1', '2', '3'};sizeof(arr) = 3;strlen(arr)=3注意:当数组作为函数参数传递当时候,表示当是指针,不能用sizeof...
  • sizeof()是C语言中常用的运算符,可以计算操作数的大小。sizeof的结果是无符号整数类型,通常用size_t表示。sizeof可以应用于各种数据类型,包括基本的数据类型,例如整数和浮点类型,指针类型和符合数据类型,...
  • sizeof求二维数组的行列大小

    万次阅读 2011-07-20 15:14:19
    <br />#include "stdio.h"  #include "conio.h"  #define M 2 #define N 3 main()  {  int a[M][N];  <br
  • sizeof(数组名)和sizeof(指针)

    万次阅读 多人点赞 2014-03-06 21:24:10
    请问sizeof(p)的值为() A、4 B、10 C、40 D、8 我以为正确答案为C,int类型为32位,占四个字节,10个自然就是40了,结果正确答案为A,只是指针p占的空间。 因此写段代码测试一下: #include using
  • 注意sizeof 返回值类型

    万次阅读 2011-03-27 11:04:00
    假设有代码片段:int a[]={1,2,3,4,5};...应该是0次,问题的关键在于sizeof的返回值类型,是一个size_t型,而size_t是这样定义的,typedef unsigned int size_t,也就是说它是一个unsigned int型。因此当执行i
  • sizeof是如何计算数组大小的

    万次阅读 2018-01-23 16:56:43
    sizeof是如何计算数组大小的 char *ptr; char arr[10]; sizeof(ptr) =4; sizeof(arr) =10;请问是如何计算数组大小的?这里只是把地址传给sizeof啊 严格讲, sizeof(arr) =10; 这里只是把地址传给...
1 2 3 4 5 ... 20
收藏数 1,466,415
精华内容 586,566
关键字:

sizeof