前言
我们知道数组和指针关系密切,特别是数组名还有数组元素的数据类型,只要记住以下规则就比较容易解决大部分问题,但是二维数组还是要注意一些细节
1. sizeof(数组名),这里的数组名表示整个数组,计算的是整个数组的大小。
2. &数组名,这里的数组名表示整个数组,取出的是整个数组的地址。
3. 除此之外所有的数组名都表示首元素的地址。
接下来我们比较详细简介一下指针和数组之间的关系
一维数组
int a[] = {1,2,3,4};
char arr[] = { 'a','b','c','d','e','f' };
char arr[] = "abcdef";//[a b c d e f \0]
char* p = "abcdef";
二维数组
int a[3][4]={0};
二维数组可以看作每个元素为一维数组
a[0] a[1] a[3] 可以看作是每一行数组的数组名,它们的数据 类型是int (*)[4]
笔试题目(文末)
int main()
{
//一维数组
int arr[4]={1,2,3,4};
//sizeof(a));//规则一,a是整个数组大小,4*4=16个字节
printf("%d\n", sizeof(a + 0));//只有括号内不是数组名a或者&a就是数组首元素地址,a+0跳过0个字节还是首元素地址,八个字节
printf("%d\n", sizeof(*a));//括号内不是数组名或者&数组名就表示首元素地址,*a解引用就是1,四个字节
printf("%d\n", sizeof(a+1));//括号内不是数组名或者&数组名就表示首元素地址,a+1就是第二个元素的地址,八个字节
printf("%d\n", sizeof(a[1]));//括号内不是数组名或者&数组名就表示首元素地址,a[1]元素2,四个字节
printf("%d\n", sizeof(&a));//整个数组的地址,地址都是八个字节
printf("%d\n", sizeof(*&a));//1.*&a=a, a就是整个数组大小 4*4=16 个字节
// 2.以类型视角看待 &a类型是int *[4]数组指针,指向是有四个元素的数组首元素地址
//解引用数组指针就是访问这个数组,16个字节
printf("%d\n", sizeof(&a+1));//&a 是整个数组的地址,&a+1跳过16个字节,地址的大小是8个字节
printf("%d\n", sizeof(&a[0]));//首元素的地址,8个字节
printf("%d\n", sizeof(&a[0]+1));//&a[0]是首元素的地址,&a[0]+1,跳过四个字节也就是第二个元素的地址,八个字节
return 0;
}
#include <string.h> // //int main() //{ // char arr[] = { 'a','b','c','d','e','f' }; // // printf("%d\n", strlen(arr));//因为字符数组arr中没有\0,所以在求字符串长度的时候,会一直往后找,产生的结构就是随机值 // printf("%d\n", strlen(arr + 0));//arr + 0是首元素的地址,和第一个一样,也是随机值 // //printf("%d\n", strlen(*arr));//err, arr是数组首元素的地址,*arr就是数组首元素,就是'a'-97 // //strlen函数参数的部分需要传一个地址,当我们传递的是'a'时,'a'的ASCII码值是97,那就是将97作为地址传参 // //strlen就会从97这个地址开始统计字符串长度,这就非法访问内存了 // //printf("%d\n", strlen(arr[1]));//err // printf("%d\n", strlen(&arr));//&arr是数组的地址,数组的地址和数组首元素的地址,值是一样的,那么传递给strlen函数后,依然是从数组的第一个元素的位置开始往后统计 // // printf("%d\n", strlen(&arr + 1));//随机值 // printf("%d\n", strlen(&arr[0] + 1));//&arr[0] + 1是第二个元素的地址。结果也是随机值 // // // //printf("%d\n", sizeof(arr));//数组名单独放在sizeof内部,这里的arr表示整个数组,计算的是整个数组的大小,单位是字节,总共6个字节 // char [6] // //printf("%d\n", sizeof(arr + 0));//arr表示数组首元素的地址,arr+0还是数组首元素的地址,是地址就是4/8个字节 // char* // //printf("%d\n", sizeof(*arr));//arr表示数组首元素的地址,*arr就是首元素,大小1个字节 // char // //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));//第二个元素的地址,是4/8个字节 // // return 0; //} // //int main() //{ // char arr[] = "abcdef";//[a b c d e f \0] // // printf("%d\n", strlen(arr));//6 arr是首元素地址,从a地址开始算到\0结束(不包括\0) // printf("%d\n", strlen(arr + 0));//6 arr首元素地址,arr+0=arr // //printf("%d\n", strlen(*arr));//err *arr='a',a的ASCII为97,地址97不是该数组所在字符的地址,属于非法访问 // //printf("%d\n", strlen(arr[1]));//err arr[1]==*(arr+1)的值为b,也是非法访问 // printf("%d\n", strlen(&arr));//6 &arr的值也是首元素的地址 // printf("%d\n", strlen(&arr + 1));//随机值,&arr的数据类型是int(*)[4],&arr+1就跳过这个数据对象大小指向\0末尾位置,strlen()函数从这个位置开始找\0,什么时候找到什么时候结束,所以是随机值 // printf("%d\n", strlen(&arr[0] + 1));//5 &arr[0]数据类型是char*,&arr[0]+1跳过一个字节指向第二个元素b // // // //printf("%d\n", sizeof(arr));//7 数组arr单独放入sizeof()内部表示整个数组的地址 // char [7] // //printf("%d\n", sizeof(arr + 0));//arr + 0是首元素的地址 // //printf("%d\n", sizeof(*arr));//*arr其实就是首元素,1个字节 // *arr--> *(arr+0) -- arr[0] // //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; //} // // //int main() //{ // char* p = "abcdef"; // // 012345 // // printf("%d\n", strlen(p));//6 传入首元素地址遇到'\0'停下,一共6个字符 // printf("%d\n", strlen(p + 1));//5 传入第二个元素的地址,遇到'\0'停下,5个字符 // //printf("%d\n", strlen(*p));//err 传入是字符a,不是这个数组相关的地址 // //printf("%d\n", strlen(p[0]));//err p[0]=*(p+0)还是字符a,不是地址 // printf("%d\n", strlen(&p));//随机值 这里传入是指针变量p的地址,随机值 // printf("%d\n", strlen(&p + 1));//随机值 指针变量p的地址+1,也是随机值 // printf("%d\n", strlen(&p[0] + 1));//第一个元素的地址,因为&p[0]类型为char* // &p[0]是第一个元素地址,&p[0]+1就是跳过一个字节就是第二个元素的地址,结果为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',就是1个字节& // //printf("%d\n", sizeof(p[0]));//p[0]--> *(p+0) --> *p 1个字节 // // //printf("%d\n", sizeof(&p));//地址的大小是4/8 // &p -- char** // //printf("%d\n", sizeof(&p + 1));//地址的大小 // 4/8 // //printf("%d\n", sizeof(&p[0] + 1));//4/8 , &p[0] + 1得到是'b'的地址 // // return 0; //}
//int main() //{ // int a[3][4] = { 0 }; // // 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]作为第一行的数组名,没有单独放在sizeo内部,没有& // //a[0]表示数组首元素的地址,也就是a[0][0]的地址 // //所以a[0]+1是第一行第二个元素的地址,是地址就是4/8个字节 // // // printf("%d\n", sizeof(*(a[0] + 1)));//4 // //计算的是就是第一行第2个元素的大小 // // printf("%d\n", sizeof(a + 1));//4 / 8 // //a是数组首元素的地址,是第一行的地址 int(*)[4] // //a+1 就是第二行的地址 // // printf("%d\n", sizeof(*(a + 1)));//16 // //*(a+1) --> a[1] -> sizeof(*(a+1))->sizeof(a[1]) 计算的是第二行的大小 // //a+1 --> 是第二行的地址,int(*)[4] // //*(a+1) 访问的第二行的数组 // // printf("%d\n", sizeof(&a[0] + 1));//4/8 // //&a[0]是第一行的地址 int(*)[4] // //&a[0]+1 是第二行的地址 int(*)[4] // // printf("%d\n", sizeof(*(&a[0] + 1)));//16 计算的是第二行的大小 // // printf("%d\n", sizeof(*a));//计算的是第一行的大小-16 // //a是数组首元素的地址,就是第一行的地址 // //*a 就是第一行 // //*a --> *(a+0) --> a[0] // // printf("%d\n", sizeof(a[3]));//16 // //a[3]--> int [4] // // // return 0; //}
指针和数组相关的题目
(1)
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数据类型是数组指针int (*)[5] , &a+1跳过20个字节 就指向了5的下一个位置,把它转换成int* 改变了指针的加减步长
用指针int*ptr接收,*(ptr-1)就是减去一个四字节(整型指针减一就是减去四个字节)也就是指向了5的位置然后解引用就是5,*(a+1)a是首元素地址加一解引用就是2
(2)
int main() { int a = 7; short s = 4; printf("%d\n", sizeof(s = a + 2));//short 2 printf("%d\n", s);// return 0; }
程序经过编译----------l链接----------生成可执行文件---------运行(计算)-------结果
表达式有两个属性
1.值属性 s=9
2.数据类型属性 s=a+2-------(short)
为什么s不是9呢? 因为sizeof()运算符压根就不会对表达式进行计算,它在编译阶段就会判断s的数据类型为short,它只关心括号里面的最终的数据类型,而表达式计算是运行阶段的,这里的sizeof()里面的表达是不进行计算,sizeof只对数据类型进行判断
(3)
struct Test { int Num; char* pcName; short sDate; char cha[2]; short sBa[4]; }* p = (struct Test*)0x100000; //假设p 的值为0x100000。 如下表表达式的值分别为多少? //已知,结构体Test类型的变量大小是20个字节 int main() { printf("%p\n", p + 0x1); printf("%p\n", (unsigned long)p + 0x1); printf("%p\n", (unsigned int*)p + 0x1); return 0; }
0x1这里是16进制,0x100000
p+0x100000 p 的指针类型是结构体类型大小为20个字节,0x100000十进制就是1,p+1就是跳过20个字节
也就是 0x100000+0x1=0x100020
(unsigned long)p p值是0x100000 强制转换成无符号整型 这时p就是数值 ,(unsigned int*)p + 0x1)就是数值加1,(unsigned long)p + 0x1=0x100001
(unsigned int*)p + 0x1 p 转换成int* 类型 这是p+1就是跳过四个字节,也就是0x100004
(4)
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);
int* ptr1 = (int*)(&a + 1);
&a+1指向的是数组元素4的下一个地址,(int*)(&a+1)转换成int *类型
ptr1[-1]=*(ptr-1) ptr1-1指向的是4 的地址,解引用就是4
int* ptr2 = (int*)((int)a + 1);
a是数组名指向的首元素地址,强转为int类型变成数值,(int)a+1就是数值加一,然后又强转成int*类型,也就是如下图,不过访问*ptr2在vs中是没权限访问这个地址
(5)
int main() { int a[3][2] = { (0, 1), (2, 3), (4, 5) }; int* p; p = a[0]; printf("%d", p[1]); return 0; }
数值中有逗号表达式,返回的逗号最右边的那个值,
int a[3][2]={1,3,5};--------->因为是个二维,数组实际存储变为 int a[3][2]={{1,3},{5,0},{0,0}};
所以p = a[0] p是第一行的数组的地址,p[1]=*(p+1)也就是第一行数组的第二个元素
(6)
int main() { int aa[2][5] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 } int* ptr1 = (int*)(&aa + 1); //&aa是整个数组的地址,它的类型是int *[2][5],&aa+1就是跳过整个数组一共40个字节,指向10的下一个位置地址,然后被强制转换为int*类型 int* ptr2 = (int*)(*(aa + 1)); //aa是二维数组的首元素地址类型为int*[5],aa+1就是跳过20个字节也就是6的地址,然后被强制转换为int*类型 printf("%d,%d", *(ptr1 - 1), *(ptr2 - 1)); //ptr-1因为ptr1是整型指针,减一跳过四个字节也就是指向5的位置,ptr2同样的方式指向10的位置 return 0; }
(8)
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]);//-4
//指针与指针相减结果就是两指针之间的元素的个数 //10000000000000000000000000000100 -4的原码 //11111111111111111111111111111011 反码 //1111 1111 1111 1111 1111 1111 1111 1100 补码 //F F F F F F F C //0xFFFFFFFC
(9)
int main() { char* a[] = { "work","at","alibaba" }; char** pa = a; pa++; printf("%s\n", *pa); return 0; }数组中a中的元素数据类型是char*,元素的地址类型是char** // //数组a中存储的是字符“work” "at""alibaba"的首元素地址。pa是二级指针存储数组的地址,pa++就是指向"at"地址
(10)
int main() { char* c[] = { "ENTER","NEW","POINT","FIRST" }; char** cp[] = { c + 3,c + 2,c + 1,c }; char*** cpp = cp; printf("%s\n", **++cpp);//cpp指向的是数组cp 的地址 ++cpp相当于cpp+=1,这时cpp指向c+2的地址,第一次解引用得到c+2的地址然后再次解引用得到POINT printf("%s\n", *-- * ++cpp + 3); printf("%s\n", *cpp[-2] + 3); printf("%s\n", cpp[-1][-1] + 1); return 0; }
//cpp指向的是数组cp 的地址 ++cpp相当于cpp+=1,这时cpp指向c+2的地址,第一次解引用得到c+2的地址然后再次解引用得到POINT // *-- * ++cpp + 3 根据优先级,先算加号的左边,cpp由于前面操作指向了c+2,++cpp同时cppy指向了c+1 解引用得到了c+1的地址,然后又--,地址减一得到C的地址同时cpp指向了c,c就是ENTER,c+3得到c中E的地址 //*cpp[-2] + 3,cpp[-2]可以理解为*(*(cpp-2))+3,cpp-2将得到c+3的地址,然后解引用得到ENTER首元素地址,最后 c+3得到S的地址 cpp[-1][-1] + 1 cpp[-1][-1]相当于*(*(cpp-1)-1)+1, //cpp-1得到c+2的地址,解引用得到POINT的地址,*(cpp-1)-1 得到NEW的地址,解引用得到NEW首元素的地址,在加1得到NEW中E的地址