前言:指针与数组的知识往往让我们无法给自己定位,似乎是懂了,但真的碰上了又一言难尽。接下来有一些关于指针与数组的知识和例题讲解,来看看你对指针和数组到底有多了解吧!
sizeof值关注占用空间的大小,单位是字节,不关注元素的类型,是一个操作符。
strlen是计算字符串中\0之前出现了多少个字符,只针对字符串,是一个库函数。
数组名是数组首元素地址,但是在这里有两个例外:
(1)sizeof(数组名),这里的数组名表示的是整个数组,计算的是整个数组的大小,单位是字节。
(2)&数组名,这里的数组名也表示整个数组,取出的是数组的地址
除了上面两种情况外,所有的数组名表示的都是数组首元素地址。
下面我们就来看一看数组、指针的一些运用
#include<stdio.h> int main() { //一维数组 int a[] = {1,2,3,4}; printf("%d\n",sizeof(a));// 16 printf("%d\n",sizeof(a+0));// 4/8 printf("%d\n",sizeof(*a));// 4 printf("%d\n",sizeof(a+1));// 4/8 printf("%d\n",sizeof(a[1]));// 4 printf("%d\n",sizeof(&a));// 4/8 printf("%d\n",sizeof(*&a));// 16 printf("%d\n",sizeof(&a+1));// 4/8 printf("%d\n",sizeof(&a[0]));// 4/8 printf("%d\n",sizeof(&a[0]+1));// 4/8 return 0; }
接下来我们就一句一句讲解:
sizeof(a)
数组名a单独放在sizeof内部,计算的是整个数组的大小,单位是字节,所以计算结果:4*4=16个字节。
sizeof(a+0)
a没有单独存放,所以表示的是首元素的地址,a+0还是数组首元素的地址,是地址的话大小就是4/8个字节。(在32位环境下为4,64位环境下为8)
sizeof(*a)
a表示的是首元素的地址,*a就是对首元素的地址解引用,所以就是首元素,大小为4个字节
sizeof(a+1)
a表示首元素地址,a+1就是第二个元素的地址,是地址的话大小就是4/8个字节。
sizeof(a[1])
a[1]表示数组的第二个元素,大小是4个字节。
sizeof(&a)
&a表示的是整个数组的地址,数组的地址也是地址,所以大小为4/8个字节。
sizeof(*&a)
&a是数组的地址,类型是int(*)[4],是一个数组指针,如果解引用,访问的就是4个int的数组,可以理解为*与&抵消效果,所以*&a相当于a,所以sizrof(a)是16。
sizeof(&a+1)
&a是数组地址,&a+1跳过整个数组后的地址,是地址就是4/8个字节大小。
sizeof(&a[0])
&a[0]取出的是数组第一个元素的地址,是地址就是4/8个字节大小。
sizeof(&a[0]+1)
&a[0]+1就是第二个元素的地址,是地址大小就是4/8个字节。
#include<stdio.h> int main() { //字符数组 char arr[] = {'a','b','c','d','e','f'}; printf("%d\n", sizeof(arr));// 6 printf("%d\n", sizeof(arr+0));// 4/8 printf("%d\n", sizeof(*arr));// 1 printf("%d\n", sizeof(arr[1]));// 1 printf("%d\n", sizeof(&arr));// 4/8 printf("%d\n", sizeof(&arr+1));// 4/8 printf("%d\n", sizeof(&arr[0]+1));// 4/8 printf("%d\n", strlen(arr));// 随机值 printf("%d\n", strlen(arr+0));// 随机值 printf("%d\n", strlen(*arr));// err printf("%d\n", strlen(arr[1]));// err printf("%d\n", strlen(&arr));// 随机值 printf("%d\n", strlen(&arr+1));// 随机值 printf("%d\n", strlen(&arr[0]+1));// 随机值 return 0; }
1、sizeof
sizeof(arr)
arr作为数组名单独存放在sizeof内部,计算的是整个数组的大小,所以是6个字节。
sizeof(arr+0)
arr没有单独存放,所以这里的arr表示的是首元素地址,arr+0还是首元素地址,是地址就是4/8个字节大小。
sizeof(*arr)
arr表示数组的首元素地址,*arr表示的就是首元素,由于是char类型,所以是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]是第一个元素的地址,&arr[0]+1就是第二个元素的地址,地址就是4/8个字节。
2、strlen
strlen(arr)
arr是首元素地址,但是arr数组中没有\0,计算的时候不知道什么时候停止,所以结果是随机值。
strlen(arr+0)
arr+0还是首元素地址,同上
strlen(*arr)、strlen(arr[1])
strlen需要的是一个地址,从这个地址开始向后计算字符,直到碰上\0停止,统计字符的个数,而*arr是首元素'a',也就是传给strlen的是'a'的ASCII码值97,strlen会把97作为起始地址,统计字符串,会形成内存访问冲突,所以会报错!arr[1]也一样,是第二个元素'b'。
strlen(&arr)
&arr是arr数组的地址,虽然类型和strlen的参数类型有所差异,但是传参过去后,还是从第一个字符的位置向后数字符,而arr数组中没有\0,所以结果还是随机值。
strlen(&arr+1)
跳过整个数组,但还是不知道哪里会出现\0,所以结果还是随机值。
strlen(&arr[0]+1)
&arr[0]表示首元素的地址,&arr[0]+1表示第二个元素的地址,也就是从第二个字符还是往后数,但由于\0不能确定所以还是随机值。
下面这个就用来自测吧!
#include<stdio.h> int main() { char arr[] = "abcdef"; printf("%d\n", sizeof(arr));// 7 整个数组的大小,包括\0 printf("%d\n", sizeof(arr+0));// 4/8 printf("%d\n", sizeof(*arr));// 1 printf("%d\n", sizeof(arr[1]));// 1 printf("%d\n", sizeof(&arr));// 4/8 printf("%d\n", sizeof(&arr+1));// 4/8 printf("%d\n", sizeof(&arr[0]+1));// 4/8 printf("%d\n", strlen(arr));// 6 printf("%d\n", strlen(arr+0));// 6 printf("%d\n", strlen(*arr));// err printf("%d\n", strlen(arr[1]));// err printf("%d\n", strlen(&arr));// 6 printf("%d\n", strlen(&arr+1));// 随机值 printf("%d\n", strlen(&arr[0]+1));// 5 return 0; }
#include<stdio.h> int main() { char *p = "abcdef"; printf("%d\n", sizeof(p));// 4/8 printf("%d\n", sizeof(p+1));// 4/8 printf("%d\n", sizeof(*p));// 1 printf("%d\n", sizeof(p[0]));// 1 printf("%d\n", sizeof(&p));// 4/8 printf("%d\n", sizeof(&p+1));// 4/8 printf("%d\n", sizeof(&p[0]+1));// 4/8 printf("%d\n", strlen(p));// 6 printf("%d\n", strlen(p+1));// 5 printf("%d\n", strlen(*p));// err printf("%d\n", strlen(p[0]));// err printf("%d\n", strlen(&p));// 随机值 printf("%d\n", strlen(&p+1));// 随机值 printf("%d\n", strlen(&p[0]+1));// 5 return 0; }
1、sizeof
sizeof(p)
p是一个指针变量,sizeof(p)计算的是指针变量大小,4/8个字节。
sizeof(p+1)
p是指针变量,用来存放地址的,p+1也是地址,地址大小就是4/8个字节。
sizeof(*p)
*p访问的是字符a,大小1字节。
sizeof(p[0])
p[0]相当于*(p+0),相当于*p,同上。
sizeof(&p)
&p也是地址,是地址就是4/8个字节。
sizeof(&p+1)
&p是地址,+1是在内存中跳过p变量后的地址,还是地址,所以为4/8字节。
sizeof(&p[0]+1)
p[0]就是a,&p[0]就是a的地址,&p[0]+1就是b的地址,是地址就是4/8个字节。
2、strlen
strlen(p)
这里的p是首元素地址,也就是'a'的地址,strlen(p)就是从'a'的位置向后求字符串的长度,长度是6。
strlen(p+1)
p是首元素地址,p+1就是第二个元素的地址,也就是'b',从b开始数直到\0,所以长度是5。
strlen(*p)、strlen(p[0])
*p、p[0]都是首元素'a',传的是a的ASCII码值,会有警报。
strlen(&p)、strlen(&p+1)
&p是指针p的地址,也就是算p的地址的字符串长度,由于不知道什么时候碰到\0,所以是随机值;&p+1就是跳过p的地址访问字符,\0未知,所以也是随机值。如图:
strlen(&p[0]+1)
&p[0]就是首元素地址,+1就是从第二个元素开始计算,长度为5;p[0]也可以看做*(p+0),也就是*p。
#include<stdio.h> int main() { //二维数组 int a[3][4] = {0}; printf("%d\n",sizeof(a)); // 48 printf("%d\n",sizeof(a[0][0])); // 4 printf("%d\n",sizeof(a[0])); // 16 printf("%d\n",sizeof(a[0]+1)); // 4/8 printf("%d\n",sizeof(*(a[0]+1)));// 4 printf("%d\n",sizeof(a+1)); // 4/8 printf("%d\n",sizeof(*(a+1))); // 16 printf("%d\n",sizeof(&a[0]+1)); // 4/8 printf("%d\n",sizeof(*(&a[0]+1))); // 16 printf("%d\n",sizeof(*a)); // 16 printf("%d\n",sizeof(a[3])); // 16 return 0; }
sizeof(a)
这里的a表示的是整个数组,所以大小为4*(3*4)=48。
sizeof(a[0][0])
a[0][0]表示第一行第一列的元素,由于数组是int型,所以一个元素的字节大小为4.
sizeof(a[0])
a[0]表示第一行的数组名,a[0]作为数组名单独放在sizeof内部,计算的是整个数组大小,即第一行的大小,4*4=16。
sizeof(a[0]+1)
这里的a[0]作为第一行的数组名,没有&,没有单独放在sizeof内部,所以a[0]表示的就是首元素的地址,即a[0][0]的地址,a[0]+1就是第一行第二个元素的地址,是地址就是4/8。
sizeof (*(a[0]+1))
a[0]+1就是第一行第二个元素的地址,对其解引用,就是第一行第二个元素,大小为4。
sizeof(a+1)
a是二维数组的数组名,是类型为 int(*)[4] 的数组指针,没有&,没有单独存放在sizeof内部,a表示首元素的地址,即第一行的地址,a+1就是第二行地址,是地址,大小就为4/8个字节。
sizeof (*(a+1))
(a+1)就是第二行元素的地址,解引用就是第二行的数组名,计算的是第二行的大小,所以大小为16个字节。( *(a+1) --> a[1] )
sizeof(&a[0]+1)
a[0]是第一行,&a[0]是地址,&a[0]+1就是第二行的地址,是地址大小就为4/8字节。
sizeof (*(&a[0]+1))
对第二行的地址解引用,也就是a[1],大小为16字节。
sizeof(*a)
a是二维数组的数组名,没有&,没有单独放在sizeof内部,a表示首元素地址,*a就是二维数组的首元素,也就是第一行,大小为16字节。( *a --> *(a+0) --> a[0] )
sizeof(a[3])
a[3]看起来是越界了,但是计算的时候它会去推导要计算的类型,例如:
int a=10; sizeof(int)和 sizeof(a)计算的大小一样,它会去推导a的类型是int型。同理,它也会去推导a[3]的类型,a[3]的类型是 int [4],所以大小为16。
通过上面的一些讲解,接下来我们看一些实战题:
#include<stdio.h> int main() { int a[5] = { 1, 2, 3, 4, 5 }; int *ptr = (int *)(&a + 1); printf( "%d,%d", *(a + 1), *(ptr - 1)); return 0; } //程序的结果是什么?
讲解 :
如图,a是数组名,也就是首元素的地址,a+1就是第二个元素的地址,对(a+1)解引用就是第二个元素2,打印出来2;
ptr是一个指针,指向的是数组的末尾,且被强制转换成int *类型,所以ptr-1跳过的是一个int,对其解引用就是数组的最后一个元素5。
#include<stdio.h> 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); printf("%p\n", (unsigned long)p + 0x1); printf("%p\n", (unsigned int*)p + 0x1); return 0; }
讲解:
已知这里的p是一个结构体指针,p+0x1就相当于结构体指针+1,而这个结构体类型的变量大小是20个字节,也就是加了20个字节,化为十六进制为0x100014;
(unsigned long) p把p强制转换成unsigned long型,这里的p就相当于是一个无符号类型的数,内存里面就默认为存的就是一个普普通通的整形数字,整型数字加1就是加1,所以结果为0x100001;
(unsigned int *)p把p强制转换成unsigned int *,这里的p就是整型指针,而整型指针加1就是加4个字节,所以结果为0x100004。
#include<stdio.h> 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); return 0; }
如图,ptr1就是&a+1,跳过整个数组,再强制转换成int * 型,而ptr1[-1]相当于 *(ptr1-1),也就是跳过一个int * 型,所以ptr1[-1]==4,用%x打印出来也是4;
(int *)((int)a + 1),a是首元素地址,强转换为int型,也就是把这个地址看成普普通通的整型数字,一个整型数字加1就是简简单单的加1,是地址这个数字+1,而不是地址+1,所以跳过的是一个字节。而我们知道数据在内存中的存储分大小端,这里我们以小端为例,如图ptr2指向的是一个整型中的第二个字节,从第二个字节开始取出一个整型,以小端输出,所以结果为02000000。
#include <stdio.h> int main() { int a[3][2] = { (0, 1), (2, 3), (4, 5) }; int *p; p = a[0]; printf( "%d", p[0]); return 0; }
讲解:
这里要看清楚题目,数组里面的是圆括号,所以是逗号表达式,数组其实就是
int a[3][2] = { 1, 3, 5 };
p = a[0] 即p指向的是数组的第一行,p[0]就是数组第一行一个元素,所以打印出来是1。
#include<stdio.h> 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; }
这里p是一个数组指针,p指向的数组是4个元素,而a是一个5行5列的数组,如下图:
好了,今天就讲到这里!这些是否让你对数组和指针有了新的看法呢?