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

    千次阅读 多人点赞 2018-08-30 09:23:15
    sizeof是关键字 sizeof是数据类型关键字,而非函数。 类型 关键字 数据类型14个 void,char,int,float,double,short,long,signed, unsigned,struct,union,enum,typedef,sizeof 控制类型6个 auto,...

    sizeof是关键字

    • sizeof是数据类型关键字,而非函数。
    类型 关键字
    数据类型14个 void,char,int,float,double,short,long,signed, unsigned,struct,union,enum,typedef,sizeof
    控制类型6个 auto,static,extern,register,const,volstile
    控制关键字12个 return,continue,break,goto,if,else,switch,case,default,for,do,while

    扩展:预处理指令不是C语言中的语言类型

    • 语言类型分5大类:

      • 表达式语句
      • 函数调用语句
      • 控制语句(if语句、switch语句……)
      • 复合语句
      • 空语句
    • 预处理指令的结尾不能添加分号,所以预处理指令不是语句。

    sizeof与strlen的区别

    int main(int argc,char* argv[]){
        cout << strlen("\0") << endl; //0
        cout << sizeof("\0") << endl; //2
        getchar();
        return 0;
    }
    • strlen执行的计数器的工作,它从内存的某个位置开始扫描,直到碰到第一个字符串结束符’\0’为止,然后返回计数器值。

    • sizeof是关键字,它以字节的形式给出了其操作数的存储大小,操作数可以是一个表达式或类型名,操作数的存储大小由操作数的类型决定。

    • sizeof是关键字,strlen是函数。

    • sizeof可以用类型作为参数,而strlen只能用char*作为参数,而且必须是以‘\0’结尾。sizeof还可以以函数作为参数,例如 int g(),则sizeof(g())的值等价于sizeof(int)的值。

      • sizeof:类型(自定义类型)、函数作为参数。
      • strlen:只能char*作为参数。
    • 大部分编译程序的sizeof都是在编译的时候计算,而strlen在运行期间计算。

      • sizeof:编译期间计算
      • strlen:运行期间计算
    • 数组作为参数传递给函数时传的是指针而非数组,传递的是数组的首地址。

    void g(char ch[]){
        cout << sizeof(ch) <<endl; //4
    }
    
    int main(int argc,char* argv[]){
        char ch[8];
        cout << sizeof(ch) <<endl; //8
        g(ch);
        getchar();
        return 0;
    }

    为什么结构体sizeof返回的值一般大于期望值?

    • 结构体的sizeof是所有成员对齐后长度相加,而union共用体的sizeof是取最大的成员长度

    • 按照最大成员长度对齐,即最大成员的整数倍。

    #include<iostream>
    
    using namespace std;
    
    struct A1 {
        int a;
        char c;
        A1();
        ~A1(){}
    };
    
    struct A2 {
        double d;
        float f;
        int a;
        char c;
        A2();
        ~A2() {}
    };
    
    int main(int argc, char* argv[]) {
        cout << sizeof(A1) << endl;  //8
        cout << sizeof(A2) << endl;  //24
        getchar();
        return 0;
    }

    sizeof计算栈中分配的大小

    • sizeof只计算栈中分配的大小,静态变量存放在全局数据区,不加入运算。
    #include<iostream>
    
    using namespace std;
    
    struct A1 {
        int a;
        char c;
        static char c1;   //BSS段,不属于栈区
        A1();
        ~A1(){}
    };
    
    struct A2 {
    private:
        static double d1;
        double d;
        float f;
        int a;
        char c;
        A2();
        ~A2() {}
    };
    
    int main(int argc, char* argv[]) {
        cout << sizeof(A1) << endl;   //8
        cout << sizeof(A2) << endl;   //24
        getchar();
        return 0;
    }

    sizeof时指针和引用的区别

    • 引用进行sizeof操作得到的是所指向的变量(对象)的大小

    • 指针进行sizeof操作得到的是指针本身(所指向的变量(对象)的地址)的大小。

    #include<iostream>
    
    using namespace std;
    
    struct A {
        int a;
        char c;
    };
    
    int main(int argc, char* argv[]) {
        A a;
        A &b = a;
        cout << sizeof(b) << endl;  //8
        A *c = &a;
        cout << sizeof(c) << endl;  //4
        getchar();
        return 0;
    }

    sizeof之虚函数

    • 虚函数是由虚函数表和虚表指针来动态绑定的,在计算sizeof时,无论有多少个虚函数,其只计算sizeof(虚表指针)=4(64位为8)。
    #include<iostream>
    
    using namespace std;
    
    struct A1 {
        int a;
        char c;
        static char c1;   //BSS段,不属于栈区
        A1();
        ~A1() {}
        virtual void f1() {}
        virtual void f2() {}
        virtual void f3() {}
    };
    
    int main(int argc, char* argv[]) {
        cout << sizeof(A1) << endl;  //12
        getchar();
        return 0;
    }

    sizeof之继承

    • 基类的sizeof结果只与基类有关。

    • 因存在继承关系,所以派生类的sizeof结果需要加上基类的sizeof结果

    • 当基类和派生类均有虚函数时,只计算一次sizeof(虚表指针)

    #include<iostream>
    
    using namespace std;
    
    struct A1 {
        int a;
        char c;
        static char c1;   //BSS段,不属于栈区
        A1();
        ~A1() {}
        virtual void f1() {}
        virtual void f2() {}
        virtual void f3() {}
    };
    
    struct A2 : public A1{
        float f;
        void f1(){}
        void f2(){}
        void f3(){}
        virtual void g1(){}  
        virtual void g2(){}
    };
    
    int main(int argc, char* argv[]) {
        cout << sizeof(A1) << endl;  //12
        cout << sizeof(A2) << endl;  //16
        getchar();
        return 0;
    }
    展开全文
  • C语言基础——sizeof的用法总结

    万次阅读 多人点赞 2018-07-25 11:28:55
    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}; 
    //并不是计算数组arr所占用的内存空间大小,而是计算指针所占内存大小,32位系统指针占4字节,64位系统指针占8字节
    cout << sizeof(arr) << endl;
    //解指针,因为arr指针指向的时数组的首元素,所以实际计算的是int类型的数据所占用内存空间,int类型占4字节
    cout << sizeof(*arr) << endl;
    

     

    展开全文
  • SIZEOF

    2015-09-13 13:45:14
    sizeof的概念  sizeof是C语言的一种单目操作符;它并不是函数。以字节形式给出了其操作数的存储大小。  操作数可以是一个表达式或括在括号内的类型名。 sizeof的使用方法 用于数据类型  sizeof使用形式: ...

    sizeof的概念  

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

    sizeof的使用方法  

    用于数据类型

      sizeof使用形式: sizeof(type)
      数据类型必须用括号括住: sizeof(int)

    用于变量

      sizeof使用形式: 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的结果(以下结果都是在Linux v2.6 gcc v4获取)

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


    1、ANSI C正式规定字符类型为1字节。    
     
    sizeof(char) = 1;
    sizeof(unsigned char) = 1;
    sizeof(signed char) = 1;
      
    2、其他类型在ANSI C中没有具体规定,大小依赖于实现。    
        sizeof(int)            = 4;
        sizeof(unsigned int)   = 4;
        sizeof(short int)      = 2;
        sizeof(unsigned short) = 2;
        sizeof(long int)       = 4;
        sizeof(unsigned long)  = 4;
        sizeof(float)          = 4;
        sizeof(double)         = 8;
        sizeof(long double)    = 12;

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

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

        例如:

              char a[5];
              int  b[5];
              sizeof(a) = 5;
              sizeof(b) = 20;

    5、当操作数是具体的字符串或者数值时,会根据具体的类型进行相应转化。 

        例如: 

              sizeof(8)    = 4;  //自动转化为int类型
              sizeof(8.8)  = 8;  //自动转化为double类型,注意,不是float类型
              sizeof("ab") = 3   //自动转化为数组类型,
                                         
    6、当操作数是联合类型时,sizeof是其最大字节成员的字节数。
           当操作数是结构类型时,sizeof是其成员类型的总字节数,包括补充字节在内。
        
        还是让我们拿例子来说话:
        union  u{             //对union来说
              char c;
              double d;
        }u;
        sizeof(u) = max(sizeof(c),sizeof(d)) = sizeof(1,8) = 8;

     struct a{             //对struct来说
              char b; 
              double x;
        }a;   
      在Linux上: sizeof(a) = 12;或者16.

        而一般sizeof(char) + sizeof(double) = 9; 因为编译器在考虑对齐问题时,在结构中插入空位以控制各成员对象的地址对齐。
        但如果全对齐的话,sizeof(a) = 16, 这是因为b被放到偏移量为0的地址,占1个字节;
        在存放x时,double类型长度为8,需要放到能被8整除的偏移量上,这时候需要补7个空字节,达到8个,这时候偏移量为8,放上x后长度为16。
        在此例中,所有的结构成员都要放在被4整除的地址(Linux的存放方式),这里补3个字节,所以为12。

    7、当操作数是函数中的数组形参或函数类型的形参:   
        sizeof给出其指针的大小,Linux中值为4。

    sizeof与其他操作符的关系

      sizeof的优先级为2级,比/、%等3级运算符优先级高。
        它可以与其他操作符一起组成表达式:

    sizeof的主要用途 

      1、主要用途是与存储分配和I/O系统那样的例程进行通信。例如: 

    void *malloc(size_t size);
    size_t fread(void *ptr, size_t size, size_t nmemb, FILE * stream);    
    
      2、另一个的主要用途是计算数组中元素的个数。例如:  
     void *memset(void *s, int c, sizeof(s));


    展开全文
  • Sizeof

    2015-04-15 20:43:08
    sizeof的用法
    #include <stdio.h>
    #include <string.h>


    void fun(int b[100])  
    {  
        printf("sizeof(b) is %d\n",sizeof(b));  
    }  
      
    int main(void)   
    {  
        int *p=NULL;  
        int a[100];  
        int b[100];  
        printf("sizeof(p) is %d\n",sizeof(p));  
        printf("sizeof(*p) is %d\n",sizeof(*p));  
        printf("sizeof(a[100]) is %d\n",sizeof(a[100])); 
        printf("sizeof(a[99]) is %d\n",sizeof(a[99])); 
        printf("sizeof(a) is %d\n",sizeof(a));  
        printf("sizeof(&a) is %d\n",sizeof(&a));
        printf("sizeof(b) is %d\n",sizeof(b));  
        printf("sizeof(&b) is %d\n",sizeof(&b));
        printf("sizeof(&a[0] is %d\n",sizeof(&a[0]));  
        printf("sizeof(&b[0] is %d\n",sizeof(&b[0]));  
        //  
        fun(b);  
        return 1;  

    }  

    -------------------------------------------------------------------输出结果

    sizeof(p) is 4

    sizeof(*p) is 4

    sizeof(a[100]) is 4

    sizeof(a[99]) is 4

    sizeof(a) is 400

    sizeof(&a) is 400

    sizeof(b) is 400

    sizeof(&b) is 400

    sizeof(&a[0] is 4

    sizeof(&b[0] is 4

    sizeof(b) is 4

    Press any key to continue

    展开全文
  • C语言 sizeof操作符详解

    万次阅读 多人点赞 2012-02-09 21:33:59
    sizeof,一个其貌不扬的家伙,引无数菜鸟竟折腰,小虾我当初也没少犯迷糊,秉着“ 辛苦我一个,幸福千万人”的伟大思想,我决定将其尽可能详细的总结一下。 但当我总结的时候才发现,这个问题既可以简单,又可以复杂...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 75,091
精华内容 30,036
热门标签
关键字:

sizeof