精华内容
下载资源
问答
  • sizeof用法
    万次阅读 多人点赞
    2020-08-20 15:56:45

    一、sizeof是什么

    sizeof是C语言的一种单目操作符,如C语言的其他操作符++、–等。它并不是函数。sizeof操作符以字节形式给出了其操作数的存储大小。操作数可以是一个表达式或括在括号内的类型名。操作数的存储大小由操作数的类型决定。

    二、sizeof的使用方法

    1、用于数据类型 
      sizeof使用形式:sizeof(type) 
      数据类型必须用括号括住。如sizeof(int)。

    2、用于变量

    sizeof使用形式:sizeof(var_name)或sizeof var_name

    变量名可以不用括号括住。如sizeof (var_name),sizeof var_name等都是正确形式。带括号的用法更普遍,大多数程序员采用这种形式。

    注意:sizeof操作符不能用于函数类型,不完全类型或位字段。不完全类型指具有未知存储大小的数据类型,如未知存储大小的数组类型、未知内容的结构或联合类型、void类型等。

    如sizeof(max)若此时变量max定义为int max(),sizeof(char_v) 若此时char_v定义为char char_v [MAX]且MAX未知,sizeof(void)都不是正确形式。

    三、sizeof的结果

    sizeof操作符的结果类型是size_t,它在头文件中typedef为unsigned int类型。该类型保证能容纳实现所建立的最大对象的字节大小。

    1、若操作数具有类型char、unsigned char或signed char,其结果等于1。

    ANSI C正式规定字符类型为1字节。

    2、int、unsigned int 、short int、unsigned short 、long int 、unsigned long 、 float、double、long double类型的sizeof 在ANSI C中没有具体规定,大小依赖于实现,一般可能分别为2、2、2、2、 4、4、4、8、10。

    3、当操作数是指针时,sizeof依赖于编译器。例如Microsoft C/C++7.0中,near类指针字节数为2,far、huge类指针字节数为4。一般Unix的指针字节数为4。

    4、当操作数具有数组类型时,其结果是数组的总字节数。

    5、联合类型操作数的sizeof是其最大字节成员的字节数。结构类型操作数的sizeof是这种类型对象的总字节数,包括任何垫补在内。

    让我们看如下结构:

    struct {char b; double x;} a;

    在某些机器上sizeof(a)=12,而一般sizeof(char)+ sizeof(double)=9。

    这是因为编译器在考虑对齐问题时,在结构中插入空位以控制各成员对象的地址对齐。如double类型的结构成员x要放在被4整除的地址。

    6、如果操作数是函数中的数组形参或函数类型的形参,sizeof给出其指针的大小。

    四、sizeof与其他操作符的关系

    sizeof的优先级为2级,比/、%等3级运算符优先级高。它可以与其他操作符一起组成表达式。如i*sizeof(int);其中i为int类型变量。

    五、sizeof的主要用途

    1、sizeof操作符的一个主要用途是与存储分配和I/O系统那样的例程进行通信。例如: 
      void *malloc(size_t size), 
      size_t fread(void * ptr,size_t size,size_t nmemb,FILE * stream)。 
      2、sizeof的另一个的主要用途是计算数组中元素的个数。例如: 
      void * memset(void * s,int c,sizeof(s))。 
    由于操作数的字节数在实现时可能出现变化,建议在涉及到操作数字节大小时用sizeof来代替常量计算。

    六、sizeof在各种类型上使用详解

    1、 sizeof应用在结构上的情况

    请看下面的结构:

    struct MyStruct
    {
    double dda1;
    char dda;
    int type
    };

    对结构MyStruct采用sizeof会出现什么结果呢?sizeof(MyStruct)为多少呢?也许你会这样求:

    sizeof(MyStruct)=sizeof(double)+sizeof(char)+sizeof(int)=13

    但是当在VC中测试上面结构的大小时,你会发现sizeof(MyStruct)为16。你知道为什么在VC中会得出这样一个结果吗?

    其实,这是VC对变量存储的一个特殊处理。为了提高CPU的存储速度,VC对一些变量的起始地址做了“对齐”处理。在默认情况下,VC规定各成员变量存放的起始地址相对于结构的起始地址的偏移量必须为该变量的类型所占用的字节数的倍数。下面列出常用类型的对齐方式(vc6.0,32位系统)。

    类型对齐方式(变量存放的起始地址相对于结构的起始地址的偏移量)
    Char偏移量必须为sizeof(char)即1的倍数
    int偏移量必须为sizeof(int)即4的倍数
    float偏移量必须为sizeof(float)即4的倍数
    double偏移量必须为sizeof(double)即8的倍数
    Short偏移量必须为sizeof(short)即2的倍数

    各成员变量在存放的时候根据在结构中出现的顺序依次申请空间,同时按照上面的对齐方式调整位置,空缺的字节VC会自动填充。同时VC为了确保结构的大小为结构的字节边界数(即该结构中占用最大空间的类型所占用的字节数)的倍数,所以在为最后一个成员变量申请空间后,还会根据需要自动填充空缺的字节。

    下面用前面的例子来说明VC到底怎么样来存放结构的。

    struct MyStruct
    {
    double dda1;
    char dda;
    int type
    };

    为上面的结构分配空间的时候,VC根据成员变量出现的顺序和对齐方式,先为第一个成员dda1分配空间,其起始地址跟结构的起始地址相同(刚好偏移量0 刚好为sizeof(double)的倍数),该成员变量占用sizeof(double)=8个字节;接下来为第二个成员dda分配空间,这时下一个可以分配的地址对于结构的起始地址的偏移量为8,是sizeof(char)的倍数,所以把dda存放在偏移量为8的地方满足对齐方式,该成员变量占用 sizeof(char)=1个字节;接下来为第三个成员type分配空间,这时下一个可以分配的地址对于结构的起始地址的偏移量为9,不是sizeof (int)=4的倍数,为了满足对齐方式对偏移量的约束问题,VC自动填充3个字节(这三个字节没有放什么东西),这时下一个可以分配的地址对于结构的起始地址的偏移量为12,刚好是sizeof(int)=4的倍数,所以把type存放在偏移量为12的地方,该成员变量占用sizeof(int)=4个字节;这时整个结构的成员变量已经都分配了空间,总的占用的空间大小为:8+1+3+4=16,刚好为结构的字节边界数(即结构中占用最大空间的类型所占用的字节数sizeof(double)=8)的倍数,所以没有空缺的字节需要填充。所以整个结构的大小为:sizeof(MyStruct)=8+1+ 3+4=16,其中有3个字节是VC自动填充的,没有放任何有意义的东西。

    下面再举个例子,交换一下上面的MyStruct的成员变量的位置,使它变成下面的情况:

    struct MyStruct
    {
    char dda;
    double dda1;
    int type
    };

    这个结构占用的空间为多大呢?在VC6.0环境下,可以得到sizeof(MyStruc)为24。结合上面提到的分配空间的一些原则,分析下VC怎么样为上面的结构分配空间的。(简单说明)

    struct MyStruct
    {
    char dda;//偏移量为0,满足对齐方式,dda占用1个字节;
    double dda1;//下一个可用的地址的偏移量为1,不是sizeof(double)=8
    //的倍数,需要补足7个字节才能使偏移量变为8(满足对齐
    //方式),因此VC自动填充7个字节,dda1存放在偏移量为8
    //的地址上,它占用8个字节。
    int type;//下一个可用的地址的偏移量为16,是sizeof(int)=4的倍
    //数,满足int的对齐方式,所以不需要VC自动填充,type存
    //放在偏移量为16的地址上,它占用4个字节。
    };//所有成员变量都分配了空间,空间总的大小为1+7+8+4=20,不是结构
    //的节边界数(即结构中占用最大空间的类型所占用的字节数sizeof
    //(double)=8)的倍数,所以需要填充4个字节,以满足结构的大小为
    //sizeof(double)=8的倍数。

    所以该结构总的大小为:sizeof(MyStruc)为1+7+8+4+4=24。其中总的有7+4=11个字节是VC自动填充的,没有放任何有意义的东西。

    VC对结构的存储的特殊处理确实提高CPU存储变量的速度,但是有时候也带来了一些麻烦,我们也屏蔽掉变量默认的对齐方式,自己可以设定变量的对齐方式。

    VC中提供了#pragma pack(n)来设定变量以n字节对齐方式。n字节对齐就是说变量存放的起始地址的偏移量有两种情况:第一、如果n大于等于该变量所占用的字节数,那么偏移量必须满足默认的对齐方式,第二、如果n小于该变量的类型所占用的字节数,那么偏移量为n的倍数,不用满足默认的对齐方式。结构的总大小也有个约束条件,分下面两种情况:如果n大于所有成员变量类型所占用的字节数,那么结构的总大小必须为占用空间最大的变量占用的空间数的倍数;

    否则必须为n的倍数。下面举例说明其用法。

    #pragma pack(push) //保存对齐状态
    #pragma pack(4)//设定为4字节对齐
    struct test
    {
    char m1;
    double m4;
    int m3;
    };
    #pragma pack(pop)//恢复对齐状态

    以上结构的大小为16,下面分析其存储情况,首先为m1分配空间,其偏移量为0,满足我们自己设定的对齐方式(4字节对齐),m1占用1个字节。接着开始为m4分配空间,这时其偏移量为1,需要补足3个字节,这样使偏移量满足为n=4的倍数(因为sizeof(double)大于n),m4占用8个字节。接着为m3分配空间,这时其偏移量为12,满足为4的倍数,m3占用4个字节。这时已经为所有成员变量分配了空间,共分配了16个字节,满足为n的倍数。如果把上面的#pragma pack(4)改为#pragma pack(16),那么我们可以得到结构的大小为24。(请读者自己分析)

    2、 sizeof用法总结

    在VC中,sizeof有着许多的用法,而且很容易引起一些错误。下面根据sizeof后面的参数对sizeof的用法做个总结。

    A. 参数为数据类型或者为一般变量。例如sizeof(int),sizeof(long)等等。这种情况要注意的是不同系统系统或者不同编译器得到的结果可能是不同的。例如int类型在16位系统中占2个字节,在32位系统中占4个字节。

    B. 参数为数组或指针。数组的sizeof就是数组所占用的内存字节数,而指针变量的sizeof与指针的对象没有任何关系,
    char a[] = “abc”;//sizeof(a)=4,字符串末尾还存在一个NULL终止符。
    int a[50]; //sizeof(a)=4*50=200; 求数组所占的空间大小
    int *a=new int[50];// sizeof(a)=4; a为一个指针,sizeof(a)是求指针的大小,在32位系统中,当然是占4个字节。

    C. 参数为结构或类。Sizeof应用在类和结构的处理情况是相同的。但有两点需要注意,
    第一、结构或者类中的静态成员不对结构或者类的大小产生影响,因为静态变量的存储位置与结构或者类的实例地址无关。
    第二、没有成员变量的结构或类的大小为1,因为必须保证结构或类的每一个实例在内存中都有唯一的地址。
    D.联合体union。结构体在内存组织上是顺序式的,联合体则是重叠式的,各成员共享一段内存,所以整个联合体的sezeof也就是每个成员的sizeof的最大值。

    下面举例说明:

    Class Test{int a;static double c};//sizeof(Test)=4.
    Test *s;//sizeof(s)=4,s为一个指针。
    Class test1{ };//sizeof(test1)=1;

    D. 参数为其他。下面举例说明。
    int func(char s[5]);
    {
    cout<sizeof(s);
    //参数在传递的时候系统处理为一个指针,所
    //以sizeof(s)实际上为求指针的大小。
    return 1;
    }
    sizeof(func(“1234”))=4//因为func的返回类型为int,所以相当于
    //求sizeof(int).

    以上为sizeof的基本用法,在实际的使用中要注意分析VC的分配变量的分配策略,这样的话可以避免一些错误。

    更多相关内容
  • sizeof用法

    2015-02-10 15:46:30
    详细解释了sizeof用法,包括函数入口参数,数组与sizeof之间的用法。包括sizeof的概念、sizeof的使用方法、sizeof与其他操作符的关系、sizeof与指针之间的关系等
  • sizeof是C#中非常重要的方法,本文就以实例形式分析C#中sizeof用法。分享给大家供大家参考。具体分析如下: 在C#中,sizeof用来计算类型的大小,单位是字节。有这样的一个类: public class MyUglyClass { ...
  • C语言中sizeof用法

    2020-11-03 10:17:47
    (二)使用方法 1、用于数据类型 sizeof使用形式:sizeof(type) ,如sizeof(int) 2、用于变量 sizeof使用形式:sizeof(var_name)或sizeof var_name 变量名可以不用括号括住。如sizeof (var_name),...

     sizeof()简单介绍

    (一)基本概念

        sizeof操作符以字节形式给出了其操作数的存储大小。操作数可以是一个表达式或括在括号内的类型名。操作数的存储大小由操作数的类型决定。

    (二)使用方法

    1、用于数据类型

        sizeof使用形式:sizeof(type) ,如sizeof(int)

    2、用于变量

        sizeof使用形式:sizeof(var_name)或sizeof var_name

        变量名可以不用括号括住。如sizeof (var_name),sizeof var_name等都是正确形式。带括号的用法更普遍,大多数程序员采用这种形式。

        注意:sizeof操作符不能用于函数类型,不完全类型或位字段。不完全类型指具有未知存储大小的数据类型,如未知存储大小的数组类型、未知内容的结构或联合类型、void类型等。

        如sizeof(max)若此时变量max定义为int max(),sizeof(char_v) 若此时char_v定义为char char_v [MAX]且MAX未知,sizeof(void)都不是正确形式。

    (三)sizeof应用在结构上的情况

        请看下面的结构:
    struct MyStruct
    {   
    double doub;
    char ch;  
    int i;
    };


       对结构MyStruct采用sizeof会出现什么结果呢?sizeof(MyStruct)为多少呢?也许你会这样求:

     

       sizeof(MyStruct)=sizeof(double)+sizeof(char)+sizeof(int)=13

    以下是测试代码:
    #include
    using namespace std;
    struct MyStruct
    {
        double doub;
        char ch;
        int i;
    };

     

    int main()
    {
        MyStruct ms;
        cout << sizeof(ms) << endl;
        return 0;
    }


    测试结果:

     

       但是当在VC中测试上面结构的大小时,你会发现sizeof(ms)为16。其实,这是VC对变量存储的一个特殊处理。为了提高CPU的存储速度,VC对一些变量的起始地址做了“对齐”处理。在默认情况下,VC规定各成员变量存放的起始地址相对于结构的起始地址的偏移量必须为该变量的类型所占用的字节数的倍数。

    常用类型的对齐方式

    类型对齐方式(变量存放的起始地址相对于结构的起始地址的偏移量)
    char偏移量必须为sizeof(char)即1的倍数
    int偏移量必须为sizeof(int)即4的倍数
    double偏移量必须为sizeof(double)即8的倍数
    short偏移量必须为sizeof(short)即2的倍数
    float偏移量必须为sizeof(float)即4的倍数

    各成员变量在存放的时候根据在结构中出现的顺序依次申请空间,同时按照上面的对齐方式调整位置,空缺的字节VC会自动填充。同时VC为了确保结构的大小为结构的字节边界数(即该结构中占用最大空间的类型所占用的字节数)的倍数,所以在为最后一个成员变量申请空间后,还会根据需要自动填充空缺的字节。
    struct MyStruct

     

    {

        double doub;

        char ch;

        int i;

    };
       为上面的结构分配空间的时候,VC根据成员变量出现的顺序和对齐方式,先为第一个成员doub分配空间,其起始地址跟结构的起始地址相同(刚好偏移量0刚好为sizeof(double)的倍数),该成员变量占用sizeof(double)=8个字节;接下来为第二个成员ch分配空间,这时下一个可以分配的地址对于结构的起始地址的偏移量为8,是sizeof(char)的倍数,所以把ch存放在偏移量为8的地方满足对齐方式,该成员变量占用sizeof(char)=1个字节;接下来为第三个成员i分配空间,这时下一个可以分配的地址对于结构的起始地址的偏移量为9,不是sizeof(int)=4的倍数,为了满足对齐方式对偏移量的约束问题,VC自动填充3个字节(这三个字节没有放什么东西),这时下一个可以分配的地址对于结构的起始地址的偏移量为12,刚好是sizeof(int)=4的倍数,所以把i存放在偏移量为12的地方,该成员变量占用sizeof(int)=4个字节;这时整个结构的成员变量已经都分配了空间,总的占用的空间大小为:8+1+3+4=16,刚好为结构的字节边界数(即结构中占用最大空间的类型所占用的字节数sizeof(double)=8)的倍数,所以没有空缺的字节需要填充。所以整个结构的大小为:sizeof(MyStruct)=8+1+3+4=16,其中有3个字节是VC自动填充的,没有放任何有意义的东西。

     

        下面再举个例子,交换一下上面的MyStruct的成员变量的位置,使它变成下面的情况:

    复制代码代码如下:


    struct MyStruct
    {
        char ch;
        double doub;
        int i;
    };


        在VC环境下,可以得到sizeof(MyStruct)为24。结合上面提到的分配空间的一些原则,分析下VC怎么样为上面 的结构分配空间:


    struct MyStruct

     

    {

        char ch;        // 偏移量为0,满足对齐方式,ch占用1个字节;

        double doub;    //下一个可用的地址的偏移量为1,不是sizeof(double)=8

                        //的倍数,需要补足7个字节才能使偏移量变为8(满足对齐

                        //方式),因此VC自动填充7个字节,doub存放在偏移量为8

                        //的地址上,它占用8个字节。

        int i;            //下一个可用的地址的偏移量为16,是sizeof(int)=4的倍

                        //数,满足int的对齐方式,所以不需要VC自动填充,i存

                        //放在偏移量为16的地址上,它占用4个字节。

    };                    //所有成员变量都分配了空间,空间总的大小为1+7+8+4=20,不是结构

                        //的节边界数(即结构中占用最大空间的类型所占用的字节数sizeof

                        //(double)=8)的倍数,所以需要填充4个字节,以满足结构的大小为

                        //sizeof(double)=8的倍数。


        所以该结构总的大小为:sizeof(MyStruct)为1+7+8+4+4=24。其中总的有7+4=11个字节是VC自动填充的,没有放任何有意义的东西。

     

        VC对结构的存储的特殊处理确实提高CPU存储变量的速度,但是有时候也带来了一些麻烦,我们也屏蔽掉变量默认的对齐方式,自己可以设定变量的对齐方式。

        VC中提供了#pragma pack(n)来设定变量以n字节对齐方式。n字节对齐就是说变量存放的起始地址的偏移量有两种情况:第一,如果n大于等于该变量所占用的字节数,那么偏移量必须满足默认的对齐方式,第二,如果n小于该变量的类型所占用的字节数,那么偏移量为n的倍数,不用满足默认的对齐方式。结构的总大小也有个约束条件,分下面两种情况:如果n大于所有成员变量类型所占用的字节数,那么结构的总大小必须为占用空间最大的变量占用的空间数的倍数;否则必须为n的倍数。

    下面举例说明其用法:
    #pragma pack(push)  //保存对齐状态
    #pragma pack(4)        //设定为4字节对齐
    struct MyStruct
    {
        char ch;
        double doub;
        int i;
    };
    #pragma pack(pop)    //恢复对齐状态
    测试结果:

    (四)sizeof用法总结

    1. 参数为数据类型或者为一般变量。

        例如sizeof(int),sizeof(long)等等。这种情况要注意的是不同系统系统或者不同编译器得到的结果可能是不同的。例如int类型在16位系统中占2个字节,在32位系统中占4个字节。

    2. 参数为数组或指针。

        下面举例说明.
    int a[50];         //sizeof(a)=4*50=200; 求数组所占的空间大小

    int *a = new int[50]; // sizeof(a)=4; a为一个指针,sizeof(a)是求指针的大小,在32位系统中,当然是占4个字节。


    3.  参数为其他。
    int func(char s[5])
    {
        return 1;              //函数的参数在传递的时候系统处理为一个指针,所以sizeof(s)实际上为求指针的大小。
    }
    sizeof(func("1234")); //因为func的返回类型为int,所以相当于求sizeof(int),其值为4.

    展开全文
  • 本篇文章是对一个关于sizeof用法的题目进行了详细的分析介绍,需要的朋友参考下
  •  printf(“%d\n”, sizeof(i++)); printf(“%d\n”, i); return 0; }这三行输出应该是什么?答案是:10410第三个为什么不是11? i为什么没有自增?请看C++标准;5.3.3 sizeofThe sizeof operator yields the ...
  • C++ sizeof用法

    2020-05-12 23:35:33
    sizeof操作符的作用是返回一个对象或类型名的长度,长度的单位是字节。 返回值的类型是标准库命名为size_t的类型,size_t类型定义在cstddef头文件中,该头文件是C标准库的头文件stddef.h的C++版本。他是一个和 机器...

    sizeof操作符的作用是返回一个对象或类型名的长度,长度的单位是字节。

    返回值的类型是标准库命名为size_t的类型,size_t类型定义在cstddef头文件中,该头文件是C标准库的头文件stddef.h的C++版本。他是一个和
    机器相关的unsigned类型,其大小足以保证内存中对象的大小。

     

    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 a value of type size_t.

      看到return这个字眼,是不是想到了函数?错了,sizeof不是一个函数,你见过给一个函数传参数,而不加括号的吗?sizeof可以,所以sizeof不是函数。网上有人说sizeof是一元操作符,但是我并不这么认为,因为sizeof更像一个特殊的宏,它是在编译阶段求值的。举个例子:

    cout<<sizeof(int)<<endl; // 32位机上int长度为4
    cout<<sizeof(1==2)<<endl; // == 操作符返回bool类型,相当于 cout<<sizeof(bool)<<endl;


      在编译阶段已经被翻译为:

    cout<<4<<endl;
    cout<<1<<endl;


      这里有个陷阱,看下面的程序:

    int a = 0;
    cout<<sizeof(a=3)<<endl;
    cout<<a<<endl;


      输出为什么是4,0而不是期望中的4,3???就在于sizeof在编译阶段处理的特性。由于sizeof不能被编译成机器码,所以sizeof作用范围内,也就是()里面的内容也不能被编译,而是被替换成类型。=操作符返回左操作数的类型,所以a=3相当于int,而代码也被替换为:

    int a = 0;
    cout<<4<<endl;
    cout<<a<<endl;


      所以,sizeof是不可能支持链式表达式的,这也是和一元操作符不一样的地方。

      结论:不要把sizeof当成函数,也不要看作一元操作符,把他当成一个特殊的编译预处理。 

      2、sizeof的用法 

      sizeof有两种用法:

      (1)sizeof(object)

      也就是对对象使用sizeof,也可以写成sizeof object 的形式。

      (2)sizeof(typename)

      也就是对类型使用sizeof,注意这种情况下写成sizeof typename是非法的。下面举几个例子说明一下:

    int i = 2;
    cout<<sizeof(i)<<endl; // sizeof(object)的用法,合理
    cout<<sizeof i<<endl; // sizeof object的用法,合理
    cout<<sizeof 2<<endl; // 2被解析成int类型的object, sizeof object的用法,合理
    cout<<sizeof(2)<<endl; // 2被解析成int类型的object, sizeof(object)的用法,合理
    cout<<sizeof(int)<<endl;// sizeof(typename)的用法,合理
    cout<<sizeof int<<endl; // 错误!对于操作符,一定要加()


      可以看出,加()是永远正确的选择。

      结论:不论sizeof要对谁取值,最好都加上()。 

      3、数据类型的sizeof 

      (1)C++固有数据类型 

      32位C++中的基本数据类型,也就char,short int(short),int,long int(long),float,double, long double

      大小分别是:1,2,4,4,4,8, 10。 

      考虑下面的代码:

    cout<<sizeof(unsigned int) == sizeof(int)<<endl; // 相等,输出 1


      unsigned影响的只是最高位bit的意义,数据长度不会被改变的。

      结论:unsigned不能影响sizeof的取值。 

      (2)自定义数据类型 

      typedef可以用来定义C++自定义类型。考虑下面的问题:

    typedef short WORD;
    typedef long DWORD;
    cout<<(sizeof(short) == sizeof(WORD))<<endl; // 相等,输出1
    cout<<(sizeof(long) == sizeof(DWORD))<<endl; // 相等,输出1


      结论:自定义类型的sizeof取值等同于它的类型原形。

      (3)函数类型 

      考虑下面的问题:

    int f1(){return 0;};
    double f2(){return 0.0;}
    void f3(){} 

    cout<<sizeof(f1())<<endl; // f1()返回值为int,因此被认为是int
    cout<<sizeof(f2())<<endl; // f2()返回值为double,因此被认为是double
    cout<<sizeof(f3())<<endl; // 错误!无法对void类型使用sizeof
    cout<<sizeof(f1)<<endl; // 错误!无法对函数指针使用sizeof 
    cout<<sizeof*f2<<endl; // *f2,和f2()等价,因为可以看作object,所以括号不是必要的。被认为是double


      结论:对函数使用sizeof,在编译阶段会被函数返回值的类型取代,

      4、指针问题 

      考虑下面问题:

    cout<<sizeof(string*)<<endl; // 4
    cout<<sizeof(int*)<<endl; // 4
    cout<<sizof(char****)<<endl; // 4


      可以看到,不管是什么类型的指针,大小都是4的,因为指针就是32位的物理地址。

      结论:只要是指针,大小就是4。(64位机上要变成8也不一定)。 

      顺便唧唧歪歪几句,C++中的指针表示实际内存的地址。和C不一样的是,C++中取消了模式之分,也就是不再有small,middle,big,取而代之的是统一的flat。flat模式采用32位实地址寻址,而不再是c中的 segment:offset模式。举个例子,假如有一个指向地址 f000:8888的指针,如果是C类型则是8888(16位, 只存储位移,省略段),far类型的C指针是f0008888(32位,高位保留段地址,地位保留位移),C++类型的指针是f8888(32位,相当于段地址*16 + 位移,但寻址范围要更大)。

      5、数组问题 

      考虑下面问题:

    char a[] = "abcdef";
    int b[20] = {3, 4};
    char c[2][3] = {"aa", "bb"};

    cout<<sizeof(a)<<endl; // 7
    cout<<sizeof(b)<<endl; // 20*4
    cout<<sizeof(c)<<endl; // 6


      数组a的大小在定义时未指定,编译时给它分配的空间是按照初始化的值确定的,也就是7。c是多维数组,占用的空间大小是各维数的乘积,也就是6。可以看出,数组的大小就是他在编译时被分配的空间,也就是各维数的乘积*数组元素的大小。

      结论:数组的大小是各维数的乘积*数组元素的大小。 

      这里有一个陷阱:

    int *d = new int[10];
    cout<<sizeof(d)<<endl; // 4


      d是我们常说的动态数组,但是他实质上还是一个指针,所以sizeof(d)的值是4。

      再考虑下面的问题:

    double* (*a)[3][6];
    cout<<sizeof(a)<<endl; // 4
    cout<<sizeof(*a)<<endl; // 72
    cout<<sizeof(**a)<<endl; // 24
    cout<<sizeof(***a)<<endl; // 4
    cout<<sizeof(****a)<<endl; // 8


      a是一个很奇怪的定义,他表示一个指向 double*[3][6]类型数组的指针。既然是指针,所以sizeof(a)就是4。

      既然a是执行double*[3][6]类型的指针,*a就表示一个double*[3][6]的多维数组类型,因此sizeof(*a)=3*6*sizeof(double*)=72。同样的,**a表示一个double*[6]类型的数组,所以sizeof(**a)=6*sizeof(double*)=24。***a就表示其中的一个元素,也就是double*了,所以sizeof(***a)=4。至于****a,就是一个double了,所以sizeof(****a)=sizeof(double)=8。

    6、向函数传递数组的问题

      考虑下面的问题:
     

    #include <iostream>
    using namespace std; 

    int Sum(int i[])
    {
     int sumofi = 0;
     for (int j = 0; j < sizeof(i)/sizeof(int); j++) //实际上,sizeof(i) = 4
     {
      sumofi += i[j];
     }
     return sumofi;


    int main()
    {
     int allAges[6] = {21, 22, 22, 19, 34, 12};
     cout<<Sum(allAges)<<endl;
     system("pause");
     return 0;
    }


      Sum的本意是用sizeof得到数组的大小,然后求和。但是实际上,传入自函数Sum的,只是一个int 类型的指针,所以sizeof(i)=4,而不是24,所以会产生错误的结果。解决这个问题的方法使是用指针或者引用。

      使用指针的情况:
     

    int Sum(int (*i)[6])
    {
     int sumofi = 0;
     for (int j = 0; j < sizeof(*i)/sizeof(int); j++) //sizeof(*i) = 24
     {
      sumofi += (*i)[j];
     }
     return sumofi;


    int main()
    {
     int allAges[] = {21, 22, 22, 19, 34, 12};
     cout<<Sum(&allAges)<<endl;
     system("pause");
     return 0;
    }


      在这个Sum里,i是一个指向i[6]类型的指针,注意,这里不能用int Sum(int (*i)[])声明函数,而是必须指明要传入的数组的大小,不然sizeof(*i)无法计算。但是在这种情况下,再通过sizeof来计算数组大小已经没有意义了,因为此时大小是指定为6的。

      使用引用的情况和指针相似: 
     

    int Sum(int (&i)[6])
    {
     int sumofi = 0;
     for (int j = 0; j < sizeof(i)/sizeof(int); j++)
     {
      sumofi += i[j];
     }
     return sumofi;


    int main()
    {
     int allAges[] = {21, 22, 22, 19, 34, 12};
     cout<<Sum(allAges)<<endl;
     system("pause");
     return 0;
    }


      这种情况下sizeof的计算同样无意义,所以用数组做参数,而且需要遍历的时候,函数应该有一个参数来说明数组的大小,而数组的大小在数组定义的作用域内通过sizeof求值。因此上面的函数正确形式应该是:
     

    #include <iostream>
    using namespace std; 

    int Sum(int *i, unsigned int n)
    {
     int sumofi = 0;
     for (int j = 0; j < n; j++)
     {
      sumofi += i[j];
     }
     return sumofi;


    int main()
    {
     int allAges[] = {21, 22, 22, 19, 34, 12};
     cout<<Sum(i, sizeof(allAges)/sizeof(int))<<endl;
     system("pause");
     return 0;
    }


      7、字符串的sizeof和strlen

      考虑下面的问题: 
     

    char a[] = "abcdef";
    char b[20] = "abcdef";
    string s = "abcdef"; 

    cout<<strlen(a)<<endl; // 6,字符串长度
    cout<<sizeof(a)<<endl; // 7,字符串容量
    cout<<strlen(b)<<endl; // 6,字符串长度
    cout<<strlen(b)<<endl; // 20,字符串容量
    cout<<sizeof(s)<<endl; // 12, 这里不代表字符串的长度,而是string类的大小
    cout<<strlen(s)<<endl; // 错误!s不是一个字符指针。 

    a[1] = '/0';
    cout<<strlen(a)<<endl; // 1
    cout<<sizeof(a)<<endl; // 7,sizeof是恒定的


      strlen是寻找从指定地址开始,到出现的第一个0之间的字符个数,他是在运行阶段执行的,而sizeof是得到数据的大小,在这里是得到字符串的容量。所以对同一个对象而言,sizeof的值是恒定的。string是C++类型的字符串,他是一个类,所以sizeof(s)表示的并不是字符串的长度,而是类string的大小。strlen(s)根本就是错误的,因为strlen的参数是一个字符指针,如果想用strlen得到s字符串的长度,应该使用sizeof(s.c_str()),因为string的成员函数c_str()返回的是字符串的首地址。实际上,string类提供了自己的成员函数来得到字符串的容量和长度,分别是Capacity()和Length()。string封装了常用了字符串操作,所以在C++开发过程中,最好使用string代替C类型的字符串。

      我注:关于sizeof(string),好像不同的实现返回的结果不一样:

    DevCPP:4
    VS2005:32
    8、从union的sizeof问题看cpu的对界 

      考虑下面问题:(默认对齐方式) 
     

    union u
    {
     double a;
     int b;
    }; 

    union u2
    {
     char a[13];
     int b;
    }; 

    union u3
    {
     char a[13];
     char b;
    }; 

    cout<<sizeof(u)<<endl; // 8
    cout<<sizeof(u2)<<endl; // 16
    cout<<sizeof(u3)<<endl; // 13


      都知道union的大小取决于它所有的成员中,占用空间最大的一个成员的大小。所以对于u来说,大小就是最大的double类型成员a了,所以sizeof(u)=sizeof(double)=8。但是对于u2和u3,最大的空间都是char[13]类型的数组,为什么u3的大小是13,而u2是16呢?关键在于u2中的成员int b。由于int类型成员的存在,使u2的对齐方式变成4,也就是说,u2的大小必须在4的对界上,所以占用的空间变成了16(最接近13的对界)。

      结论:复合数据类型,如union,struct,class的对齐方式为成员中对齐方式最大的成员的对齐方式。 

      顺便提一下CPU对界问题,32的C++采用8位对界来提高运行速度,所以编译器会尽量把数据放在它的对界上以提高内存命中率。对界是可以更改的,使用#pragma pack(x)宏可以改变编译器的对界方式,默认是8。C++固有类型的对界取编译器对界方式与自身大小中较小的一个。例如,指定编译器按2对界,int类型的大小是4,则int的对界为2和4中较小的2。在默认的对界方式下,因为几乎所有的数据类型都不大于默认的对界方式8(除了long double),所以所有的固有类型的对界方式可以认为就是类型自身的大小。更改一下上面的程序:
     

    #pragma pack(2)
    union u2
    {
     char a[13];
     int b;
    }; 

    union u3
    {
     char a[13];
     char b;
    };
    #pragma pack(8) 

    cout<<sizeof(u2)<<endl; // 14
    cout<<sizeof(u3)<<endl; // 13


      由于手动更改对界方式为2,所以int的对界也变成了2,u2的对界取成员中最大的对界,也是2了,所以此时sizeof(u2)=14。

      结论:C++固有类型的对界取编译器对界方式与自身大小中较小的一个。 

      9、struct的sizeof问题 

      因为对齐问题使结构体的sizeof变得比较复杂,看下面的例子:(默认对齐方式下) 
     

    struct s1
    {
     char a;
     double b;
     int c;
     char d; 
    }; 

    struct s2
    {
     char a;
     char b;
     int c;
     double d;
    }; 

    cout<<sizeof(s1)<<endl; // 24
    cout<<sizeof(s2)<<endl; // 16


      同样是两个char类型,一个int类型,一个double类型,但是因为对界问题,导致他们的大小不同。计算结构体大小可以采用元素摆放法,我举例子说明一下:首先,CPU判断结构体的对界,根据上一节的结论,s1和s2的对界都取最大的元素类型,也就是double类型的对界8。然后开始摆放每个元素。

      对于s1,首先把a放到8的对界,假定是0,此时下一个空闲的地址是1,但是下一个元素d是double类型,要放到8的对界上,离1最接近的地址是8了,所以d被放在了8,此时下一个空闲地址变成了16,下一个元素c的对界是4,16可以满足,所以c放在了16,此时下一个空闲地址变成了20,下一个元素d需要对界1,也正好落在对界上,所以d放在了20,结构体在地址21处结束。由于s1的大小需要是8的倍数,所以21-23的空间被保留,s1的大小变成了24。

      对于s2,首先把a放到8的对界,假定是0,此时下一个空闲地址是1,下一个元素的对界也是1,所以b摆放在1,下一个空闲地址变成了2;下一个元素c的对界是4,所以取离2最近的地址4摆放c,下一个空闲地址变成了8,下一个元素d的对界是8,所以d摆放在8,所有元素摆放完毕,结构体在15处结束,占用总空间为16,正好是8的倍数。

      这里有个陷阱,对于结构体中的结构体成员,不要认为它的对齐方式就是他的大小,看下面的例子: 
         

    struct s1
    {
     char a[8];
    }; 
    
    struct s2
    {
     double d;
    }; 
    
    struct s3
    {
     s1 s;
     char a;
    }; 
    
    struct s4
    {
     s2 s;
     char a; 
    }; 
    
    cout<<sizeof(s1)<<endl; // 8
    cout<<sizeof(s2)<<endl; // 8
    cout<<sizeof(s3)<<endl; // 9
    cout<<sizeof(s4)<<endl; // 16;

           

      s1和s2大小虽然都是8,但是s1的对齐方式是1,s2是8(double),所以在s3和s4中才有这样的差异。

      所以,在自己定义结构体的时候,如果空间紧张的话,最好考虑对齐因素来排列结构体里的元素。 

      10、不要让double干扰你的位域 

      在结构体和类中,可以使用位域来规定某个成员所能占用的空间,所以使用位域能在一定程度上节省结构体占用的空间。不过考虑下面的代码: 
     

    struct s1
    {
     int i: 8;
     int j: 4;
     double b;
     int a:3;
    }; 

    struct s2
    {
     int i;
     int j;
     double b;
     int a;
    }; 

    struct s3
    {
     int i;
     int j;
     int a;
     double b;
    }; 

    struct s4
    {
     int i: 8;
     int j: 4;
     int a:3;
     double b;
    }; 

    cout<<sizeof(s1)<<endl; // 24
    cout<<sizeof(s2)<<endl; // 24
    cout<<sizeof(s3)<<endl; // 24
    cout<<sizeof(s4)<<endl; // 16


      可以看到,有double存在会干涉到位域(sizeof的算法参考上一节),所以使用位域的的时候,最好把float类型和double类型放在程序的开始或者最后。  

     

    c语言中判断数据类型长度符
    用法
          sizeof(类型说明符,数组名或表达式);

          sizeof 变量名

    1. 定义:
    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)成员不能被计算sizeof值,即下面这些写法都是错误的:
    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(注意结果是以字节为单位),可以预计,在将来的64位系统中指针变量的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 size, 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( trailing 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用法

    2021-02-06 10:59:54
    1、sizeof定义 sizeof是个操作符,它的作用是计算一个对象在内存所占内存的字节数,并返回这个字节数; 返回的类型是size_t. 2、怎么用?(语法) 比如有个整数型的变量 int i = 10; ...

    1、sizeof定义

    sizeof是个操作符,它的作用是计算一个对象在内存所占内存的字节数,并返回这个字节数;

    返回的类型是size_t.

    2、怎么用?(语法)

    比如有个整数型的变量
    int i = 10;
    第一种:sizeof(int);(int、float、double等等)
    第二种:sizeof i;
    第三种:sizeof(类型/对象);
    1. //32位机子下
    2. int i;
    3. sizeof( int); //字节数为4个字节
    4. sizeof(i); //4个字节
    5. sizeof i; //4个字节
    6. size( float); //4个字节
    7. size( double); //8个字节

    3、结构体的sizeof

    结构体的用法和2的用法一样,但是里面涉及到一个数据对齐的问题。
    1. struct
    2. {
    3. char a;
    4. double b;
    5. char c;
    6. }A;
    7. struct
    8. {
    9. double b;
    10. char a;
    11. char c;
    12. }B;

    如上面两个结构体A,B
    他们的字节数分别为:
    sizeof(A) : 24
    sizeof(B) : 16

    A的实际对齐情况为如下:
    |char|------|------|------|
    |---------double--------|
    |char|------|------|------|






    比如结构体A的字节数计算:
    它不是按照sizeof(A) = sizeof(a)+sizeof(b)+sizeof(c) = 1+8+1=10来计算的!!
    请注意不是按照上述情况计算的!

    结构的计算字节数有几个原则:

    原则1:

    以结构体字节数最大数据类型的倍数做偏移量对齐;

    如A结构体包含了char和double
    那就以double的字节数成倍偏移进行对齐

    那A的字节数计算为

    sizeof(A) = sizeof(b)*3 = 8*3=24

    那结构体B的计算为什么是16个字节啊?!
    这就是下面的原则了

    原则2:

    如果结构体中连续的基础数据类型没有超过结构体最大的数据类型的字节数,则可以“拼”在一块


    B的实际对齐情况为如下:

    |---------double--------|
    |char|char|------|------|

    所以sizeof(B) = sizeof(b)*2 = 8*2 = 16

    具体为什么可以这么做,我没有看到比较好的通俗解释,如果有同学看到了欢迎交流!

    以此类推
    1. struct
    2. {
    3. double a;
    4. char b;
    5. int c;
    6. }C; // 字节数为16
    7. struct
    8. {
    9. double a;
    10. int b;
    11. int c;
    12. }D; //字节数为16



    展开全文
  • C#sizeof用法

    千次阅读 2018-07-28 09:37:23
    C#中sizeof方法 用于获取 值类型 的字节大小。... 对于所有其他类型(包括 struct),sizeof ...虽然可以使用 SizeOf 方法,但该方法返回的值和 sizeof 返回的值并不总是相同的。Marshal.SizeOf 在已封送处...
  • C语言sizeof用法[借鉴].pdf
  • sizeof 用法

    2019-10-02 04:15:22
    解析C语言中的sizeof 一、sizeof的概念 sizeof是C语言的一种单目操作符,如C语言的其他操作符++、--等。它并不是函数。...二、sizeof使用方法 1、用于数据类型   sizeof使用形式:sizeof(t...
  • C 语言 sizeof 用法

    2022-02-14 15:45:48
    sizeof 是计算变量/类型在系统中所占用的字节数,那么我们在函数的调用的时候,如果将数组作为形式参数传递的话,一定要注意其长度不能用sizeof直接计算
  • sizeof用法汇总

    2016-04-04 18:30:59
    sizeof用法 一、sizeof的概念 sizeof是C语言的一种单目操作符,尤其注意的是,它不是一个函数。sizeof接收一个操作数,操作数可以是一个表达式或者是括在括号内的数据类型名。sizeof操作符以字节形式给出其操作...
  • void UpperCase( char str[] ) { for( size_t i=0;...sizeof(str)/sizeof(str[0]); ++i ) if( 'a'<=str[i] && str[i]<='z' ) str[i] -= ('a'-'A' ); } char str[] = "aBcDe"...
  • C++中sizeof用法总结

    2016-05-15 11:10:42
    1. sizeof 简介 sizeof是一个关键字,不是一个函数,其作用是返回一个对象或者类型所占的内存字节数。 MSDN上的解释为:The sizeof keyword gives the amount of storage, in bytes, associated with a variable ...
  • 二、使用方法 语法:sizeof(数据类型/变量) 例题演示: #include<stdio.h> void main(){ int a = 10;//int 型函数的字节数为4 char b = 'b';//字符型函数的字节数为1 short c = 2;//短整型字节数为2 ...
  • C语言中的sizeof用法

    千次阅读 2021-05-21 07:06:05
    C语言中的sizeof是一个很有意思的关键字,经常有人用不对,搞不清不是什么。我以前也有用错的时候,现在写一写,也算是提醒一下自己吧。反正现在来看,还在搞sizeof是什么意思,怎么用正确,还是有点搞笑,都经常用...
  • [c&c++系列]sizeof用法

    2019-07-05 12:09:29
    sizeof用法 Sizeof是C语言的一种单目操作符,如C语言的其他操作符++、–等。它并不是函数。Sizeof操作符以字节形式给出了其操作数的存储大小。操作数可以是一个表达式或括在括号内的类型名。操作数的存储大小由操作...
  • sizeof用法总结

    千次阅读 2021-07-16 16:17:56
    常见的使用方式: 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...
  • C++中sizeof用法

    2016-12-24 11:09:58
    sizeof是一个操作符(operator)。 其作用是返回一个对象或类型所占的内存字节数。 其返回值类型为size_t。(size_t在头文件stddef.h中定义,它依赖于编译系统的值,一般定义为 typedef unsigned int size_t;...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 352,877
精华内容 141,150
关键字:

sizeof用法