一、sizeof和strlen简介
[1]sizeof介绍
sizeof计算数据内存空间大小,是一种操作符
具有类型属性,只关注数据的类型,()内的表达式不进行运算
在数组中数组名arr只在两种情况下表示整个数组:
1.sizeof(数组名)中数组名表示整个数组
2.&数组名表示取出整个数组的地址
其余情况下数组名arr都表示首元素地址
[2]strlen介绍
size_t strlen(const char* str)
size_t-->unsigned int表示无符号整形
strlen是计算字符串长度的库函数,遇到'\0'时停止,计算的是'\0'之前的字符数目。
二、sizeof和strlen运用
- 一维数组中的运用
int main()
{
//一维数组
int a[] = { 1,2,3,4 };//4*4=16
printf("%d\n", sizeof(a));//16
printf("%d\n", sizeof(a + 0));//a+0 其实是数组第一个元素的地址,是地址就是4/8字节
printf("%d\n", sizeof(*a));//*a是数组首元素,计算的是数组首元素的大小,单位是字节,4
printf("%d\n", sizeof(a + 1));//a+1是第二个元素的地址,是地址大小就是4/8
printf("%d\n", sizeof(a[1]));//a[1]是第二个元素,计算的是第二个元素的大小-4-单位是字节
printf("%d\n", sizeof(&a));//&a是整个数组的地址,整个数组的地址也是地址,地址的大小就是4/8字节
//&a---> 类型:int(*)[4]
printf("%d\n", sizeof(*&a));//&a是数组的地址,*&a就是拿到了数组,*&a--> a,a就是数组名,sizeof(*&a)-->sizeof(a)
//计算的是整个数组的大小,单位是字节-16
printf("%d\n", sizeof(&a + 1));//&a是整个数组的地址,&a+1,跳过整个数组,指向数组后边的空间,是一个地址,大小是4/8字节
printf("%d\n", sizeof(&a[0]));//&a[0]是首元素的地址,计算的是首元素地址的大小,4/8字节
printf("%d\n", sizeof(&a[0] + 1));//&a[0] + 1是第二个元素的地址,地址的大小就是4/8字节
return 0;
}
![](https://i-blog.csdnimg.cn/blog_migrate/f7f11eca609663dca8d383e165592762.png)
![](https://i-blog.csdnimg.cn/blog_migrate/4326c000a40ea637d2e828ecbc510806.png)
![](https://i-blog.csdnimg.cn/blog_migrate/6c71f41a4ea2ebe6c6fe54d6018725bb.png)
2.字符数组中的运用
int main()
{
//字符数组
char arr[] = { 'a','b','c','d','e','f' };
//char*
//char [6]
printf("%d\n", strlen(arr));//'\0'的位置不确定,因此为随机值
printf("%d\n", strlen(arr + 0));//'\0'位置不确定也是随机值
printf("%d\n", strlen(*arr));//strlen('a')->strlen(97),非法访问-error,会出现问题
printf("%d\n", strlen(arr[1]));//'b'-98,和上面的代码类似,是非法访问 - error,会出现问题
printf("%d\n", strlen(&arr));//&arr虽然是数组的地址,但是也是从数组起始位置开始的,计算的还是随机值
//char(*)[6]
printf("%d\n", strlen(&arr + 1));
//&arr是数组的地址,&arr+1是跳过整个数组的地址,求字符串长度也是随机值
printf("%d\n", strlen(&arr[0] + 1));//&arr[0] + 1是第二个元素的地址,是'b'的地址,求字符串长度也是随机值
//printf("%d\n", sizeof(arr));//arr单独放在sizeof内部,计算的是整个数组的大小,单位是字节,6
//printf("%d\n", sizeof(arr + 0));//arr + 0是数组首元素的地址,4/8
//printf("%d\n", sizeof(*arr));//*arr是数组的首元素,计算的是首元素的大小-1字节
//printf("%d\n", sizeof(arr[1]));//arr[1]是第二个元素,大小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));//&arr[0] + 1是数组第二个元素的地址,是地址4/8字节
return 0;
}
int main()
{
char arr[] = "abcdef";//数组是7个元素
//[a b c d e f \0]
printf("%d\n", strlen(arr));//6,arr是数组首元素的地址,strlen从首元素的地址开始统计\0之前出现的字符个数,是6
printf("%d\n", strlen(arr + 0));//arr + 0是数组首元素的地址,同第一个,结果是6
printf("%d\n", strlen(*arr));//*arr是'a',是97,传给strlen是一个非法的地址,造成非法访问-error
printf("%d\n", strlen(arr[1]));//与上述情况相同,非法访问-error
printf("%d\n", strlen(&arr));//取出的是整个数组的地址,实际存储的数据和首元素地址一致,大小为6
printf("%d\n", strlen(&arr + 1));//&arr + 1是跳过数组后的地址,统计字符串的长度是随机值
printf("%d\n", strlen(&arr[0] + 1));//&arr[0]+1是b的地址,从第二个字符往后统计字符串的长度,大小是随机值
printf("%d\n", sizeof(arr));//数组名单独放在sizeof内部,计算的是数组的总大小,为6字节
printf("%d\n", sizeof(arr + 0));//arr+0是首元素的地址,大小是4/8
printf("%d\n", sizeof(*arr));//*arr是数组首元素,大小是1字节
printf("%d\n", sizeof(arr[1]));//arr[1]是数组的第二个元素,大小是1字节
printf("%d\n", sizeof(&arr));//&arr是数组的地址,数组的地址也是地址,是4/8字节
printf("%d\n", sizeof(&arr + 1));//&arr + 1是跳过整个数组的地址,是4/8字节
printf("%d\n", sizeof(&arr[0] + 1));//&arr[0] + 1是第二个元素的地址,是4/8字节
return 0;
}
3.指针中的运用
//int main()
//{
// const char* p = "abcdef";
// //存的是a的地址
// printf("%d\n", strlen(p));//p存放的是a的地址,求字符串长度就是6
// printf("%d\n", strlen(p + 1));//p + 1是b的地址,求字符串长度就是5
// //printf("%d\n", strlen(*p));//error,*p是'a',非法访问
// //printf("%d\n", strlen(p[0]));//error - 同上一个
// printf("%d\n", strlen(&p));//&p拿到的是p这个指针变量的起始地址,从这里开始求字符串长度完全是随机值
// printf("%d\n", strlen(&p + 1));//&p+1是跳过p变量的地址,从这里开始求字符串长度也是随机值
// printf("%d\n", strlen(&p[0] + 1));//&p[0] + 1是b的地址,从b的地址向后数字符串的长度是5
//
// //printf("%d\n", sizeof(p));//p是指针变量,大小就是4/8字节
// //printf("%d\n", sizeof(p + 1));//p + 1是b的地址,是地址,就是4/8个字节
// //printf("%d\n", sizeof(*p));//*p是'a',sizeof(*p)计算的是字符的大小,是1字节
// //printf("%d\n", sizeof(p[0]));//p[0]-->*(p+0) --> *p 就同上一个,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]就是‘a’,&p[0]就是a的地址,+1,就是b的地址,是地址就是4/8
//
// return 0;
//}
4.二维数组中的运用
//int main()
//{
// int a[3][4] = { 0 };
// //printf("%p\n", &a[0][0]);//取出第一行第一个元素的地址
// //printf("%p\n", a[0]+1);//a[0]表示第一行数组名,a[0]+1表示第一行第二个元素地址
// printf("%d\n", sizeof(a));//数组名表示整个数组,大小为3*4*4=48字节
// printf("%d\n", sizeof(a[0][0]));//第一行第一个元素,计算元素大小,为4字节
// printf("%d\n", sizeof(a[0]));//a[0]是第一行的数组名,数组名单独放在sizeof内部,计算的就是数组(第一行)的大小,16个字节
// printf("%d\n", sizeof(a[0] + 1));//a[0]作为第一行的数组名,没有单独放在sizeof内部,没有取地址,表示的就是数组首元素的地址
// //那就是a[0][0]的地址,a[0]+1就是第一行第二个元素的地址,是地址就是4/8个字节
// printf("%d\n", sizeof(*(a[0] + 1)));//*(a[0] + 1)是第一行第2个元素,计算的是元素的大小-4个字节
// printf("%d\n", sizeof(a + 1));//a是二维数组的数组名,数组名表示首元素的地址,就是第一行的地址,a+1就是第二行的地址
// //第二行的地址也是地址,是地址就是4/8
// //a - int (*)[4]
// //a+1--> int(*)[4]
// printf("%d\n", sizeof(*(a + 1)));//a+1是第二行的地址,*(a+1)表示的就是第二行,*(a+1)--a[1] //16
// printf("%d\n", sizeof(&a[0] + 1));//&a[0]是第一行的地址,&a[0]+1是第二行的地址,地址的大小就是4/8
// printf("%d\n", sizeof(*(&a[0] + 1)));//*(&a[0] + 1) 是对第二行的地址解引用,得到的就是第二行,计算的就是第二行的大小
// printf("%d\n", sizeof(*a));//a表示首元素的地址,就是第一行的地址,*a就是第一行,计算的就是第一行的大小
// //*a -- *(a+0)--a[0]
// printf("%d\n", sizeof(a[3]));//16字节 int[4]
// //如果数组存在第四行,a[3]就是第四行的数组名,数组名单独放在sizeof内部,计算的是第四行的大小
//
// return 0;
//}
在C语言中表达式有两种属性:
1.值属性
- 类型属性
//int main()
//{
// short s = 3;
// int a = 10;
// s = a + 2;
// //运算后发生截断
// printf("%d\n", sizeof(s = a + 2));//2
// //sizeof在操作时并不会计算()中的表达式,只关心是什么类型的数据
// //s为short型,因此计算结果为2
// printf("%d\n", s);
// //而单独运算s%d打印时发生整形提升,打印最终结果
// return 0;
//}
![](https://i-blog.csdnimg.cn/blog_migrate/cab9c40c6dfe885ffc570a3f944c044c.png)
sizeof在编译阶段就执行完毕,而表达式的运算需要在运行的时候开始执行,所以其内部不会发生表达式的运算,只关心()内部表达式的类型,具有类型属性
二、指针练习题
1.
//int main()
//{
// int a[5] = { 1, 2, 3, 4, 5 };
// int* ptr = (int*)(&a + 1);
// printf("%d,%d", *(a + 1), *(ptr - 1));//2,5
// return 0;
//}
![](https://i-blog.csdnimg.cn/blog_migrate/bf484f0d1caf82de2e27cf8848b549f5.png)
2.
//由于还没学习结构体,这里告知结构体的大小是20个字节
//struct Test
//{
// int Num;
// char* pcName;
// short sDate;
// char cha[2];
// short sBa[4];
//}* p;
//假设p 的值为0x100000。 如下表表达式的值分别为多少?
//已知,结构体Test类型的变量大小是20个字节
//int main()
//{
// p = (struct Test*)0x100000;
// printf("%p\n", p + 0x1);
// //0x00100014
// //结构体类指针+1跳过一个结构体,在原有地址基础上+20
// printf("%p\n", (unsigned long)p + 0x1);
// //0x00100001
// //整形家族数据+1表示的就是在原有数据基础上+1(比如3+1-->4)
// printf("%p\n", (unsigned int*)p + 0x1);
// //0x00100004
// //无符号整形指针+1跳过一个unsigned int类型数据,在原有数据基础上+4
// return 0;
//}
![](https://i-blog.csdnimg.cn/blog_migrate/32e0d431310bed44b872d0ce8193d2b6.png)
![](https://i-blog.csdnimg.cn/blog_migrate/2c56d45c0ec9c8987eddfe93555b2ebc.png)
强制类型转换是先将十六进制的地址转换为二进制,在发生截断并加上相应的值
3.
//小端,x86环境
//int main()
//{
// int a[4] = { 1, 2, 3, 4 };
// int* ptr1 = (int*)(&a + 1);
// int* ptr2 = (int*)((int)a + 1);
// printf("%x,%x", ptr1[-1], *ptr2);//0x00000004 0x02000000
// return 0;
//}
![](https://i-blog.csdnimg.cn/blog_migrate/8a87604474e65db287450fa5a07f56b8.png)
4.
//int main()
//{
// int a[3][2] = { (0, 1), (2, 3), (4, 5) };
// //1 3
// //5 0
// //0 0
// //int a[3][2] = { {0,1}, {2,3}, {4,5} };
// int* p;
// p = a[0];
// printf("%d", p[0]);//1
// return 0;
//}
逗号表达式运算顺序是从左至右,最后一个数据是最终结果。
5.
int main()
{
int a[5][5];
int(*p)[4];
p = a;
printf("%p,%d\n", &p[4][2] - &a[4][2], &p[4][2] - &a[4][2]);
return 0;
}
![](https://i-blog.csdnimg.cn/blog_migrate/715f8c3316a336da0901fed38706db6e.png)
6.
//int main()
//{
// int aa[2][5] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
//
// int* ptr1 = (int*)(&aa + 1);
// int* ptr2 = (int*)(*(aa + 1));
// printf("%d,%d", *(ptr1 - 1), *(ptr2 - 1));//10,5
//
// return 0;
//}
![](https://i-blog.csdnimg.cn/blog_migrate/092d244ba94da873a2cec9adbe55d202.png)
7.
//int main()
//{
// char* a[] = { "work","at","alibaba" };
//
// char** pa = a;
// pa++;
// printf("%s\n", *pa);
//
// return 0;
//}
![](https://i-blog.csdnimg.cn/blog_migrate/a6a12ed73804ea833b6a3163517023d0.png)
8.
//int main()
//{
// char* c[] = { "ENTER","NEW","POINT","FIRST" };
// char** cp[] = { c + 3,c + 2,c + 1,c };
// char*** cpp = cp;
//
// printf("%s\n", **++cpp);//POINT
// printf("%s\n", *-- * ++cpp + 3);//ER
// printf("%s\n", *cpp[-2] + 3);//ST
// printf("%s\n", cpp[-1][-1] + 1);//EW
//
// return 0;
//}
![](https://i-blog.csdnimg.cn/blog_migrate/e3c799526bc1e57f4775f57643ea4963.png)
![](https://i-blog.csdnimg.cn/blog_migrate/8a00ad60cf371e19691e6d4cb1a0b12c.png)
![](https://i-blog.csdnimg.cn/blog_migrate/1eacf77f8e8546347ec5f2e5dbf91a7d.png)
![](https://i-blog.csdnimg.cn/blog_migrate/02015c62bae7fc6f1023b67792bd064d.png)