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()函数 1,是什么?  sizeof其实就是一个运算符,和那些+,-一样的东西,在程序编译的时候进行解析转换。虽然我们经常见到sizeof后面跟着个小括号,长得和函数差不多,但它和函数完全是两码事。 2,有什么用? ...
  • 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;
    }
    展开全文
  • Go 类型的 Sizeof 提示 只是在组织结构时检查自己的一个小技巧。 import . "unsafe" 固定尺寸 类型 Sizeof()字节 struct{} 0 [0]Type 0 bool 1 int8 , uint8 , byte 1 int16 , uint16 2 int32 , uint32 ...
  • 详解C++ sizeof(上)

    2020-12-17 01:57:20
    sizeof是C/C++中的一个操作符(operator),其作用是返回一个对象或者类型所占的内存字节数,使用频繁,有必须对其有个全面的了解。 1.sizeof的基本语法 sizeof有三种语法形式。 (1)sizeof(object); //sizeof...
  • sizeof()的简单介绍

    2020-12-26 04:01:22
     sizeof使用形式:sizeof(type) ,如sizeof(int) 2、用于变量  sizeof使用形式:sizeof(var_name)或sizeof var_name  变量名可以不用括号括住。如sizeof (var_name),sizeof var_name等都是正确形式。带...
  •  printf(“%d\n”, sizeof(i++)); printf(“%d\n”, i); return 0; }这三行输出应该是什么?答案是:10410第三个为什么不是11? i为什么没有自增?请看C++标准;5.3.3 sizeofThe sizeof operator yields the ...
  • sizeof 运算符 产生与 char 类型的大小有关的操作数大小。 语法 sizeof unary-expression sizeof ( type-name ) 备注 sizeof 运算符的结果为 size_t 类型,它是包含文件 STDDEF.H 中定义的整数类型。利用此运算符...
  •  sizeof是C/C++中的一个操作符(operator),简单的说其作用就是返回一个对象或者类型所占的内存字节数。其返回值类型为size_t,在头文件stddef.h中定义。在32位系统中: char的sizeof值为1,char是我们编程能用的...
  • sizeof的作用 sizeof是c的运算符之一,用于获取操作数被分配的内存空间,以字节单位表示. 这里指的操作数,可以是变量,也可以是数据类型,如int,float等.所以就可以通过它来获取本地c库定义的基本类型的范围。 sizeof的...
  • sizeof是C#中非常重要的方法,本文就以实例形式分析C#中sizeof的用法。分享给大家供大家参考。具体分析如下: 在C#中,sizeof用来计算类型的大小,单位是字节。有这样的一个类: public class MyUglyClass { ...
  • 解析C语言中的sizeof

    2020-08-04 06:46:59
    一、sizeof的概念 ;二、sizeof的使用方法 ;三、sizeof的结果 ;四、sizeof与其他操作符的关系 ;五、sizeof的主要用途 ;六、建议 。
  • 深入sizeof的使用详解

    2020-09-05 07:36:32
    本篇文章是对sizeof的使用进行了详细的分析介绍,需要的朋友参考下
  • 主要给大家介绍了关于C语言中sizeof函数的基本使用的相关资料,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧。
  • NULL 博文链接:https://312256159-qq-com.iteye.com/blog/1582196
  • SizeOf.jar

    2016-11-02 12:41:06
    一个SizeOf.jar.
  • js-sizeof 一个小的(<50 loc),无依赖库,用于计算内存中 javascript 对象的粗略大小。 安装 npm install js-sizeof 用法 var sizeof = require ( 'js-sizeof' ) ; var obj = { floop : 0 , gloop : '...
  • 本篇文章是对一个关于sizeof用法的题目进行了详细的分析介绍,需要的朋友参考下
  • 在编程过程中,我们经常这样运用malloc: int * myarray=(int *)malloc(sizeof(int)*length),但是你是否知道,这一句简单的代码隐含了2个陷阱?
  • sizeof用法详解

    万次阅读 多人点赞 2020-08-20 15:56:45
    一、sizeof是什么 sizeof是C语言的一种单目操作符,如C语言的其他操作符++、–等。它并不是函数。sizeof操作符以字节形式给出了其操作数的存储大小。操作数可以是一个表达式或括在括号内的类型名。操作数的存储大小...

    一、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的分配变量的分配策略,这样的话可以避免一些错误。

    展开全文
  • 主要介绍了C语言位运算和sizeof运算符详解的相关资料,这里提供了详细的知识要点,并附简单代码示例,需要的朋友可以参考下
  • 以下是对C语言中sizeof的细节进行了详细的分析介绍,需要的朋友可以参考下
  • matlab开发-sizeof

    2019-08-26 09:25:56
    matlab开发-sizeof。返回内置数据类型的字节数。
  • 本篇文章是对不用sizeof求出int大小的方法进行了详细的分析介绍,需要的朋友参考下
  • C语言sizeof与strlen详解(附大量笔试题题解过程)

    千次阅读 多人点赞 2021-09-10 11:51:47
    一.sizeof()详解 二.strlen()详解 strlen()的模拟实现: 法1:计数器 法2:指针-指针 法3:递归 三.strlen与sizeof的区别 四.笔试题 1.整形数组int a[] = {1,2,3,4} strlen()相关题目 sizeof()相关...

    前言:相信很多初学者都对被sizeof和strlen搞得晕晕的,相信看完这篇文章,你对这二者的认识将提升一个档次!已经了解sizeof和strlen的大佬们就当复习吧,哈哈哈~


    目录

    一.sizeof()详解

    二.strlen()详解

    strlen()的模拟实现:

    法1:计数器

    法2:指针-指针

    法3:递归

    三.strlen与sizeof的区别

    四.笔试题

    1.整形数组int a[] = {1,2,3,4}

    strlen()相关题目

    sizeof()相关题目

    2.字符数组-char arr[] = {'a','b','c','d','e','f'}

    strlen()相关题目

    sizeof()相关题目

    3.字符数组-char arr[] = “abcdef”

    strlen()相关题目

    sizeof()相关题目

    4.指针指向的常量字符串-char *p = "abcdef"

    strlen()相关题目

    sizeof()相关题目

    5.二维数组-int a[3][4]

    sizeof()相关题目

    五.总结:


    一.sizeof()详解

    1.sizeof()作用:计算变量/类型所占内存大小,单位是字节

    int a = 10;
    int b =sizeof(a);    //a为int类型,大小为4个字节
    int c = sizeof(int);   //4

    2.sizeof是操作符,不是函数!!! 

    sizeof 变量 或者 sizeof(变量)都可以 

    sizeof(类型)可以      sizeof 类型是错误的

    int main()
    {
    	int a, b, c, d;
    	a = sizeof(a);
    	b = sizeof a;
    	c = sizeof(int);
    	//d = sizeof int;	//err
    	printf("%d %d %d\n", a, b, c);    // 4 4 4
    	return 0;
    }

    3.sizeof ()内部的表达式不参与真实运算!这点很重要!其运算值在编译时就计算好了 

    int main()
    {
    	int a = 10;
    	int b = sizeof(a = a + 1);
    	printf("%d %d \n", a, b);    // 10 4
    	return 0;
    }

    sizeof内部即使写的是赋值表达式也不会去真实的运算,sizeof在计算的时候只看操作数的类型,不会访问对应的空间 


    4.sizeof()与数组名的关系

    sizeof(数组名):此时的数组名代表的是整个数组

    &数组名:此时的数组名代表的也是整个数组 

    其他情况,数组名代表的是首元素地址

    int arr[10];
    a = sizeof(arr);    //计算的是整个数组的大小 4*10 = 10
    b = sizeof(&arr);   //取出整个数组的地址,是地址(指针),4/8

    5.sizeof()返回类型造成的坑

    int i ;	//全局变量未初始化系统默认为0
    int main()
    {
        i--;	//i变成-1
        if(i > sizeof(i))
        {
            printf(">\n");
        }
        else
        {
            printf("<\n");
        }
        return 0;
    }

     打印结果: >

    注意:sizeof(i)和i比较时,sizeof返回类型为size_t 而i的类型为int,最终是用size_t比较,对于-1的补码为:全1序列,如果看成是无符号数的话,对于的值比sizeof(i) = 4大


    二.strlen()

    strlen():求字符串长度的库函数,遇到\0即停止计算。需要引用#include<string.h>头文件,注意返回类型为:size_t(unsigned int 无符号整型),

    函数原型:


    strlen()的模拟实现:

    法1:计数器

    size_t my_strlen(const char* str)
    {
    	size_t count = 0;
    	while (*str != '\0')
    	{
    		count++;
    		str++;
    	}
    	return count;
    }

    法2:指针-指针

    指针-指针得到的是二者之间元素的个数。所以只要一个指针指向字符串首字符,一个指针指向\0,二者相减就是字符串长度

    size_t my_strlen2(const char* str)
    {
    	char* start = str;
    	char* end = str;
    	while (*end != '\0')
    	{
    		end++;
    	}
    	return end - start;
    }

    法3:递归

    //法3:递归
    size_t my_strlen3(const char* str)
    {
    	//如果不是\0就+1(本身指向字符),然后递归下一个字符
    	if (*str != '\0')
    		return 1 + my_strlen3(str + 1);
    	//遇到\0即返回0
    	else
    		return 0;
    }

    strlen()返回参数size_t造成的坑点:

    int main()
    {
    	char* p1 = "abcd";
    	char* p2 = "abcde";
    
    
    	if (strlen(p1) - strlen(p2)>0)
    	{
    		printf("p1>p2");
    	}
    	else
    	{
    		printf("p1<p2");
    	}
    	return 0;
    }

    上述代码打印结果:p1>p2

    strlen(p1) 结果为4  strlen(p2):结果为5  二者的类型都为size_t   无符号整形

    二者相减得到-1,也被认为是无符号整形,对应的值>0 


    三.strlen与sizeof的区别

    共同点:返回类型都是size_t

    不同点:sizeof()是操作符计算的是变量/类型所占空间的大小,单位是字节,\0也算进空间

                  strlen()是库函数,计算的是字符串长度,不计算\0

    int main()
    {
    	char arr1[] = { 'a','b','c' };
    	int ret1 = strlen(arr1);
    	int ret2 = sizeof(arr1);
    	printf("%d %d\n", ret1,ret2);    //随机值    3
    //arr1并没放入\0,strlen()向后直到找到\0才停止,所以是随机值  而arr1本身数组元素个数为3,根据后面初始化的内容确定了数组的大小,sizeof:3*1 = 3
    
    	char arr[] = "abcdef";
    	int ret3 = strlen(arr);
    	int ret4 = sizeof(arr);
    	printf("%d %d\n", ret3, ret4);    //6 7
    //arr大小为7,含\0  strlen不算\0
    	return 0;
    }

    四.笔试题

    1.整形数组int a[] = {1,2,3,4}

    sizeof()相关题目

    int main()
    {
    	int a[] = { 1,2,3,4 };
    	printf("%d\n", sizeof(a));//数组名a单独放在sizeof内部,数组名表示整个数组,计算的是整个数组的大小
    	printf("%d\n", sizeof(a + 0));//a表示首元素的地址,a+0还是首元素的地址,地址的大小是4/8字节
    	printf("%d\n", sizeof(*a));   //a表示首元素的地址,*a 就是首元素 ==> a[0] ,大小就是4
    	//*a <==> *(a+0) <==> a[0]
    	printf("%d\n", sizeof(a + 1));//a表示首元素的地址,a+1是第二个元素的地址,大小就是4/8
    	printf("%d\n", sizeof(a[1])); //a[1] 就是第二个元素 - 4
    	printf("%d\n", sizeof(&a));   //&a - 数组的地址 - 4/8 - int(*)[4]
    	printf("%d\n", sizeof(*&a));  //*&a - &a是数组的地址,对数组的地址解引用拿到的是数组,所以大小时候16
    	//相当于printf("%d\n", sizeof(a));//16
    
    	printf("%d\n", sizeof(&a + 1));//4/8 &a是数组的地址,&a+1 是数组的地址+1,跳过整个数组,虽然跳过了数组,
    	//还是地址  4/8
    	printf("%d\n", sizeof(&a[0]));//4/8
    	printf("%d\n", sizeof(&a[0] + 1));//第二个元素的地址 4/8
    	return 0;
    }

    2.字符数组-char arr[] = {'a','b','c','d','e','f'}

    strlen()相关题目

    //字符数组
    char arr[] = {'a','b','c','d','e','f'};
    //arr中是没有放\0的,而strlen()求长度是找到\0才停止
    
    printf("%d\n", strlen(arr));//从arr位置(首元素地址)向后求长度,随机值
    
    printf("%d\n", strlen(arr+0));//从arr位置(首元素地址)向后求长度,随机值
    
    //printf("%d\n", strlen(*arr));//arr是首元素地址,*arr是字符‘a’-ascii-97,strlen把字符a对应的ascii码值97作为地址向后计数,非法访问!err
    
    //printf("%d\n", strlen(arr[1]));//strlen把字符b对应的ascii码值98作为地址向后计数,非法访问!err
    
    printf("%d\n", strlen(&arr));//&arr和arr地址值相同,都是首元素地址,但是意义不一样
    //&arr传给strlen  &arr类型:数组指针 char(*p)[6] 而strlen接收的类型为char*,不兼容,但是问题不大
    //从数组首元素位置向后计数,随机值
    
    printf("%d\n", strlen(&arr+1));//跳过整个数组后,向后计数,随机值-6
    //原因:内存空间连续,同时找到\0停止,但是strlen(arr)和strlen(&arr)得到的随机值比第二个多6个字符abcdef
    
    printf("%d\n", strlen(&arr[0]+1));//从字符b位置向后计数,随机数-1

    sizeof()相关题目

    //字符数组
    char arr[] = {'a','b','c','d','e','f'};
    //&arr的类型:数组指针: char(*)[6]
    
    printf("%d\n", sizeof(arr));//数组名单独放在sizeof内部,计算的是整个数组的大小,元素个数为6个(不含\0),类型为char 所以大小为6
    
    printf("%d\n", sizeof(arr+0));//此处的arr代表的是首元素地址,arr+0仍是首元素地址char*,地址(指针)大小是4/8
    
    printf("%d\n", sizeof(*arr));//此处的arr代表的是首元素地址,*arr即为数组首元素,即为字符‘a’  大小为1
    
    printf("%d\n", sizeof(arr[1]));//arr[1]->字符‘b’,大小为1
    
    printf("%d\n", sizeof(&arr));//取出整个数组的地址,还是地址,地址的大小就是4/8  
    
    printf("%d\n", sizeof(&arr+1));//取出数组arr的地址+1,跳过一个数组,还是地址,地址的大小为:4/8
    
    printf("%d\n", sizeof(&arr[0]+1));//数组第二个元素的地址,4/8

    3.字符数组-char arr[] = “abcdef”

    strlen()相关题目

    char arr[] = "abcdef";
    //此时数组arr中存放了\0  strlen求长度,遇到\0即停止计数
    
    printf("%d\n", strlen(arr));//从arr位置开始向后计数,遇到\0即停,长度为6
    
    printf("%d\n", strlen(arr+0));///从arr位置开始向后计数,遇到\0即停,长度为6
    
    //printf("%d\n", strlen(*arr));//arr是首元素地址,*arr是字符‘a’对应ascii值为97,strlen把字符a对应的ascii码值97作为地址向后计数,非法访问!err
    
    //printf("%d\n", strlen(arr[1]));///arr[1]:‘b’对应ascii值为98,strlen把字符b对应的ascii码值98作为地址向后计数,非法访问!err
    
    printf("%d\n", strlen(&arr));&arr和arr地址值相同,都是首元素地址,但是意义不一样
    //&arr传给strlen  &arr类型:数组指针 char(*p)[6] 而strlen接收的类型为char*,不兼容,但是问题不大
    //从数组首元素位置向后计数,值为 6
    
    printf("%d\n", strlen(&arr+1));//跳过整个数组后,向后计数,未知值
    
    printf("%d\n", strlen(&arr[0]+1));//从b未知向后计数,长度为5

    sizeof()相关题目

    char arr[] = "abcdef";
    //此时的arr数组里面是放了\0的
    
    printf("%d\n", sizeof(arr));//数组名单独放在sizeof内部,计算的是整个数组的大小,\0也算进去,大小为7
    
    printf("%d\n", sizeof(arr+0));//此时的数组名是首元素地址,地址(指针)大小:4/8
    
    printf("%d\n", sizeof(*arr));//此时的数组名是首元素地址,*arr即为首元素,字符a->char类型,大小为1
    
    printf("%d\n", sizeof(arr[1]));//arr[1]:字符'b',大小为1
    
    printf("%d\n", sizeof(&arr));//取出数组的地址,还是地址,大小为4/8
    
    printf("%d\n", sizeof(&arr+1));//取出数组的地址+1,跳过整个数组,还是地址:4/8
    
    printf("%d\n", sizeof(&arr[0]+1));//取出第一个元素的地址+1,跳过一个元素,即为第二个元素的地址,4/8

    4.指针指向的常量字符串-char *p = "abcdef"

    strlen()相关题目

    const char* p = "abcdef";
    //p存放的是字符a的地址,
    //p+1:字符b的地址
    
    printf("%d\n", strlen(p));//p存放的是字符a的地址,即从字符a的地址向后计数,长度为6
    
    printf("%d\n", strlen(p+1));//从字符b的地址向后计数,长度为5
    
    //printf("%d\n", strlen(*p));//*p ->字符‘a’  即以字符a的ascii码值97为地址向后计数,非法访问,err
    
    //printf("%d\n", strlen(p[0]));//p[0] ->字符‘a’  即以字符a的ascii码值97为地址向后计数,非法访问,err
    
    printf("%d\n", strlen(&p));//&p取出的是p变量的地址,即以p变量的地址(16进制)向后计数,  随机值
    
    printf("%d\n", strlen(&p+1));//&p取出的是p变量的地址,&p+1,跳过p变量,即从p变量之后的位置向后访问  随机值
    
    printf("%d\n", strlen(&p[0]+1));//&p[0]==>相当于&*(p+0)-->相当于sizeof(p),p存中存放的是字符a的地址,+1,即为字符b的地址,从字符b位置向后访问,  长度为5
    // p[0] :字符a  
    //&p[0]:字符a的地址 
    //&p[0] +1:字符b的地址
    
    //注意上面两个随机值没有必然关系,因为strlen(&p)是以p地址对应的16进制向后访问,值为未知数,有可能提前遇到\0结束了

    sizeof()相关题目

    //因为指针指向的是常量字符串,不可以被修改
    //所以可以用const修饰
    //char* p = "abcdef";
    const char * p ="abcdef";
    //p存放的是字符a的地址
    
    printf("%d\n", sizeof(p));//p是指针,指向字符a,大小为4/8
    
    printf("%d\n", sizeof(p+1));//p+1,指向的是字符b,指针,大小为4/8
    
    printf("%d\n", sizeof(*p));//p存放的是字符a的地址,*p:即为字符a,大小为1
    
    printf("%d\n", sizeof(p[0]));//p[0]->字符a ,大小为1
    
    printf("%d\n", sizeof(&p));//取出p变量的地址,仍是地址,大小为4/8
    
    printf("%d\n", sizeof(&p+1));//取出p变量的地址+1,跳过p变量,但仍是地址,大小为4/8
    
    printf("%d\n", sizeof(&p[0]+1));//&p[0]相当于&*(p+0),&和*抵消,&p[0]:字符a的地址,+1:字符b的地址,大小为4/8

    5.二维数组-int a[3][4]

    内存布局

    实际内存结构
    想象结构

    sizeof()相关题目

    //二维数组
    int a[3][4] = {0};
    
    printf("%d\n",sizeof(a));//数组名单独放在sizeof内部,计算的是整个数组的大小, 数组元素为12个,每一个元素大小为4个字节,12*4=48
    
    printf("%d\n",sizeof(a[0][0]));//计算的是数组第有一行第一个元素的大小,int类型,大小为4
    
    printf("%d\n",sizeof(a[0]));//a[0]==>*(a+0)==>数组名是首元素地址,即为第一行的地址,解引用第一行的地址,就是第一行,所以计算的是第一行元素的大小 4*4=16
    //a[0] : 二维数组的第一行
    
    printf("%d\n",sizeof(a[0]+1));//a[0]:第一行的数组名,代表第一行第一个元素的地址,a[0]+1::跳过一个元素,即为第一行第二个元素地址,大小为4/8  
    //注意:a[0] + 1 :不是第二行,a[0]是第一行的数组名,首元素地址,即为第一行第一个元素地址,a[0]+1:跳过一个元素   a+1:a为数组名,首元素地址,第一行的地址,a+1,跳过一行,二维数组第二行
    
    printf("%d\n",sizeof(*(a[0]+1)));//由上可得:a[0]+1:第一行第二个元素地址, *(a[0]+1):即为第一行第二个元素 int类型 大小为4
    
    printf("%d\n",sizeof(a+1));//a为二维数组的数组名->首元素地址,e二维数组第一行的地址,+1,跳过一行,即为第二行的地址->地址,大小为4/8
    
    printf("%d\n",sizeof(*(a+1)));//由上,a+1是第二行的地址,*(a+1)即为第二行,大小为4*4 = 16
    
    printf("%d\n",sizeof(&a[0]+1));//a[0]是第一行的数组名,&a[0]就是第一行的地址,(相当于是,数组名和取地址数组名的关系,二二者地址值相同,但是含义不同),&a[0]+1:跳过第一行,即为第二行地址,地址:4/8
    
    printf("%d\n",sizeof(*(&a[0]+1)));//由上:(&a[0]+1):第二行地址,解引用就是第二行,大小为4*4 = 16
    
    printf("%d\n",sizeof(*a));//二维数组数组名是首元素地址,即为第一行的地址,解引用就是第一行, 大小为4* 4  = 16
    
    printf("%d\n",sizeof(a[3]));//a[3]假设存在,就是第四行的数组名,sizeof(a[3])相当于数组名单独放在sizeof内部,计算的是第四行的大小, 4*4 = 16
    
    //sizeof内部的表达式不参与运算,即不会真的去访问a[3]的空间,所以不出错,它只看一下第四行的类型,并没有真正去访问第四行的内容,

    五.总结:

    strlen()和sizeof()坑点挺多的,大家认真学习!一起加油哈哈哈!

    如果感觉对你有帮助的,欢迎点个赞评论一下呀!


    展开全文
  • PAGE / NUMPAGES Eclipse使用SizeOf.jar工具监测内存占用 原因由于项目需要需将数据库中表内容存入内存中供以后查询时减少对数据库的访问 目的检查该缓存对象占用空间大小适当调整tomcat启动内存 工具SizeOf.jar ...
  • 深入理解Sizeof

    2017-02-05 13:39:27
    深入理解Sizeof
  • sizeof用法

    2015-02-10 15:46:30
    详细解释了sizeof用法,包括函数入口参数,数组与sizeof之间的用法。包括sizeof的概念、sizeof的使用方法、sizeof与其他操作符的关系、sizeof与指针之间的关系等

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,823,542
精华内容 729,416
关键字:

sizeof