sizeof 和 strlen的对比

1.3 sizeof 和 strlen的对比

  sizeof                                                                

 1. sizeof是操作符                                        

  2.sizeof计算操作数所占内存的大小,单位是字节                                         

3.不关注内存中存放什么数据

   strlen        

1. strlen是库函数,使用需要包含头文件string.h        

2. srtlen是求字符串长度的,统计的是\0之前字符的个数

3关注内存中是否有,如果没有,就会持续往后找,可能会越界

/数组名的理解

//数组名是数组首元素(第一个元素)的地址/但是有2个例外:

//1. sizeof(数组名)- 数组名表示整个数组,计算的是整个数组的大小,单位是字节

//2. &数组名 - 数组名表示整个数组,取出的是整个数组的地址

//除此之外,所以的数组名是数组首元素(第一个元素)的地址。

1.int,类型

int a[] = { 1,2,3,4 };//数组有几个元素?

sizeof(a));//16 -- sizeof(数组名))的场景

sizeof(a + 0));//a是首元素的地址-类型是int*a+0 还是首元素的地址,是地址大小就是4/8

sizeof(*a));//a是首元素的地址,*a就是首元素,大小就是4个字节

                    //*a == a[0] == *(a+0)

sizeof(a + 1));//a是首元素的地址,类型是int*a+1跳过1个整型,a+1就是第二个元素的地址,4/8

sizeof(a[1]));//a[1]就是第二个元素,大小4个字节

sizeof(&a));//&a是数组的地址,数组的的地址也是地址,是地址大小就是4/8个字节

sizeof(*&a));//1. *& 互相抵消了,9 sizeof(*&a)= sizeof(a) --16

//2. &a 是数组的地址,类型是int(*)[4],对数组指针解引用用访问的是数组,计算的是数组的大小 --16

 sizeof(&a + 1));//&a+1是跳过整个数数组后的那个位置的地址,是地址就是4/8个字节

sizeof(&a[0]));//首元素的地址,大小4/8个字节

 sizeof(&a[0] + 1));//&a[0] +--数组第二个元素的地址,大小是4/8个字节

2.char,类型

2.1sizeof

char arr[] = { 'a','b','c','d','e'i'f' };

sizeof(arr));//数组名单独放在sizeof内部了,计算的是数组的大小,单位是字节-6

sizeof(arr + 0));//arr是数组名表示首元素素的地址,arr+0还是首元素的地址,是地址就是4/8个字节

sizeof(*arr));//arr是首元素的地址,*arr就是首元素,大小就是1个字节

                   //*arr -- arr[0] - *(arr+0)

sizeof(arr[1]));//arr[1] 是第二个元素,        大小也是1个字节        

sizeof(&arr));//&arr是数组地址,数组的地址也是地址,大小是4/8个字节

                        //&arr -- char(*)[6]

 sizeof(&arr + 1));//&arr+1,跳过整个数组,指向了数组后边的空间,4/8个字节

sizeof(&arr[0] + 1));//第二个元素的地址,是地址就是4/8字节

2.2strlen

char arr[] ={ 'a','b','c','d' ,'f'};        

strlen(arr));//arr是首元素的地址,数组中没有\0,就会导致越界访问,结果就是随机的

 strlen(arr + 0));//arr+0是数组首元素的地址,数组中没有\0,就会导致越界访问,结果就是随机白

strlen(*arr));//arr是首元素的地址,*arr是首元素,就是'a','a'的ascii码值是97

//就相当于把97作为地址传递给了strlen,strlen得到的就是野指针,代码是有问题的

strlen(arr[1]));//arr[1]--'b'--98,传给strlen函数也是错误的

 strlen(&arr));//&arr是数组的地址,起始位置是数组的第一个元素的位置,随机值 x

 strlen(&arr + 1));//随机值 x-6

 strlen(&arr[0]+1));//从第2个元素开始向后统计的,得到的也是随机值 x-1

2.3sizeof

char arr[] = "abcdef"

 sizeof(arr));//arr是数组名,单独放在sizeof内部,计算的是数组总大小,是7个字节

sizeof(arr +0));//arr表示数组首元素的地址,arr+0还是首元素的地址,是地址就是4/8 

sizeof(*arr));//arr表示数组首元素的地址,*arr就是首元素,大小是1字节

 sizeof(arr[1]));//arr[1]是第二个元素,大小1个字节

 sizeof(&arr));//&arr是数组的地址,是地址就是4/8

 sizeof(&arr + 1));//&arr是数组的地址,+1跳过整个数组,还是地址,是地址就是4/8个字节

sizeof(&arr[0] + 1));//&arr[0] + 1是第二个元素的地址,大小是4/8个字节

2.4strlen

char arr[] = "abcdef"i

 strlen(arr));//6

 strlen(arr +0));//arr首元素的地址,arr+0还是首元素的地址,向后在\0之前有6个字符

,strlen(*arr));//'a'-97,出错

 strlen(arr[1]));//'b'-98,出错

strlen(&arr));//&arr是数组的地址,也是从数组第一个元素开始向后找,6

//&arr -- char (*)[7]

strlen(&arr + 1));//随机值

 strlen(&arr[0] + 1));//5

3char*类型

3.1sizeof

const char * p = "abcdef"

 sizeof(p));//p是指针变量,我们计算的是指针变量的大小,4/8个字节

sizeof(p + 1)); //p + 1是b的地址,是地址大小就是4/8个字节

 sizeof(*p));//p的类型是const char**p就是char类型了,1个字节

sizeof(p[0]));//1. p[0] --> *(p+0)--> *p --> 'a' ,大小是1字节

//2. 把常量字符串想象成数组,p可以理解为数组名,p[0],就是首元素

sizeof(&p));//取出的是p的地址,地址的大小是4/8个字节

sizeof(&p + 1));//&p + 1是跳过p指针变量后的地址,是地址就是4/8个字节

 sizeof(&p[0] + 1));//4/8 &p[0]-取出字符串首字符的地址,+1是第二个字符的地址,大小是4/8个字节

3.2 strlen

char* p = "abcdef";

 strlen(p));//6

strlen(p + 1));//5

strlen(*p));//*p就是'a'-97,err

strlen(p[0]));//p[0]--> *(p+0)--> *p //err

strlen(&p));//&p是指针变量p的地址,和字符串"abcdef"关系就不大了

//从p这个指针变量的起始位置开始向后数的,p变量存放的地址是什么,不知道,所以答案是随机值

strlen(&p + 1));//随机值

 strlen(&p[0] + 1));//&p[0]-取出字符串首字符的地址hft1是第二个字符的地址

4二维数组

int a[3][4] = { 0 };

 sizeof(a));//a是数组名,单独放在sizeof内部,计算的是数组的大小,单位是字节-48 =3*4*sizeof(int)  sizeof(a[0][0]));//a[0][0]是第一行第一个元素,大小4个字节

sizeof(a[0]));//a[0]第一行的数组名,数组名单独放在sizeof内部了,计算的是数组的总大小16个字节

sizeof(a[0]+ 1)); //a[0]第一行的数组名,但是a[0]并没有单独放在sizeof内部,所以这里的数组名a[0]就是

//数组首元素的地址,就是&a[0][0],+1后是a[0][1]的地址,大小是4/8个字节

sizeof(*(a[0] + 1)));//*(a[0]+ 1)表示第一行第二个元素,大小就是4

 sizeof(a + 1));//a作为数组名并没有单独放在sizeof内部,a表示数组首元素的地址,是二维数组首元素的地址,也就是

//第一行的地址,a+1,跳过一行,指向了第二行,a+1是第二行的地址,a+1是数组指针,是地址大小就是4/8个字节

sizeof(*(a + 1)));//1.a+1是第二行的地址,*(a+1)就是第二行,计算的是第二行的大小 - 16

//2. *(a + 1) == a[1]a[1]是第二行的数组名,sizeof(*(a + 1))就相当于sizeof(a[1]),意思是把第二行的数组名单独放在//sizeof内部,计算的是第二行的大小

sizeof(&a[0] + 1));//a[0]是第一行的数组名,&a[0]取出的就是数组的地址,就是第一行的地址

//&a[0]+1 就是第二行的地址,是地址大小就是4/8个字节

sizeof(*(&a[0] + 1)));//*(&a[0]+ 1)意思是对第二行的地址解引用,访问的就是第二行,大小是16字节

sizeof(*a));//a作为数组名并没有单独放在sizeof内部,a表示数组首元素的地址,是二维数组首元素的地址,也就是//第一行的地址,*a就是第一行,计算的就是第一行的大小,16字节

//*a == *(a+0) == a[0]

sizeof(a[3]));//a[3]无需真实存在,仅仅通过类型的推断就能算出长度//a[3]是第四行的数组名,单独放在sizeof内部,计算的是第四行的大小,16个字节 return 0;

  • 20
    点赞
  • 16
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值