文章目录

• 一. 一维数组
• 二.字符数组
• 三.字符指针
• 四.二维数组
• 五.指针笔试题

一. 一维数组

首先说明：需熟记以下三个规则。
规则1.&数组名指的是取出整个数组的地址。
规则2.数组名被单独放在sizeof内部，计算的是整个数组的大小。
说明：这里的单独指的是不参与运算，如果不单独，按数组首元素的地址进行计算。
规则3.只要是地址的大小，就是4/8个字节（32位——X86，是4个字节,64位上是8个字节）
注意：
1.sizeof的返回值是 unsigned int
2.sizeof是操作符也是关键字，但不是函数。
3.sizeof在预编译的时候就已经处理好了，调试是看不到求解过程的！

#include
int main()
{//一维数组int a[] = {1,2,3,4};printf("%d\n",sizeof(a));//运用规则1，我们直到这里的a是整个数组的大小——>4个整形——>16个字节//所以答案是：16printf("%d\n",sizeof(a+0));//运用规则2,a不是被单独放在sizeof内部，所以里的a是数组首元素的的地址，//再运用规则3，可知地址在32位——4,64位——8，所以答案是4/8printf("%d\n",sizeof(*a));//*a运用规则2，这里的a不是单独出现，所以是数组首元素的地址，对数组首元素解引用//得出*a是数组首元素——1——>类型为int——>4个字节//答案：4printf("%d\n",sizeof(a+1));//运用规则2,a不是被单独放在sizeof内部，所以里的a是数组首元素的的地址，//对a+1得到的是数组第二个元素的地址//再运用规则3，可知地址在32位——4,64位——8，//答案是4/8printf("%d\n",sizeof(a[1]));//运用规则2，这里的a不是单独出现，所以是数组首元素的地址，这里表示的是数组的第//二个元素——2——>类型为int——>大小为4个字节//答案是：4printf("%d\n",sizeof(&a));//运用规则1,这里的&a表示的整个数组的大小，再运用规则3，只要是地址，大小就为4或//8个字节//答案是:4/8printf("%d\n",sizeof(*&a));//运用规则1：这里&a得到的是整个数组的地址，对整个数组的地址解引用，得到的为数组//名，运用规则2：数组名在sizeof内部是整个数组的大小——>4个整形->16个字节//答案:16printf("%d\n",sizeof(&a+1));//运用规则1：这里的&a指的是整个数组的地址，对整个数组加一跳过的是一个数组的大小//也就是跳过了4个整形(16个字节)，但结果还是数组指针的类型——>地址——>运用规则3，//再运用规则3，可知地址在32位——4,64位——8//答案是:4/8//说明:这里的+1之后得到的是野指针，但是我们只是计算，并不访问和修改//所以是没有问题的printf("%d\n", sizeof(&a[0]));//a首先与[]结合([]的优先级大于&)得到是数组第一个元素，对数组的元素取地址得到的//第一个元素的地址，是地址——>运用规则3->地址为4或8个字节//答案:4/8printf("%d\n",sizeof(&a[0]+1));//a首先与[]结合([]的优先级大于&)得到是数组第一个元素，对数组的元素取地址得到的//第一个元素的地址,对第一个元素的地址加一，得到的是第二个元素的地址是地址——>//运用规则3->地址为4或8个字节//答案:4/8个字节return 0;
}

到这里我们的一维数组就讲完了，再看看下面的代码思考一下，是否豁然开朗？

#include
int main()
{//一维数组int a[] = { 1,2,3,4 };printf("%d\n", sizeof(a));printf("%d\n", sizeof(a + 0));printf("%d\n", sizeof(*a));printf("%d\n", sizeof(a + 1));printf("%d\n", sizeof(a[1]));printf("%d\n", sizeof(&a));printf("%d\n", sizeof(*&a));printf("%d\n", sizeof(&a + 1));printf("%d\n", sizeof(&a[0]));printf("%d\n", sizeof(&a[0] + 1));return 0;
}

二.字符数组

#include
int main()
{char arr[] = { 'a','b','c','d','e','f' };printf("%d\n", sizeof(arr));//利用规则2：arr被单独放在sizeof内部，说明arr代表的是整个数组->6个字符->6字节//答案:6printf("%d\n", sizeof(arr + 0));//利用规则2：arr没有被单独放在sizeof内部，说明arr代表的是数组首元素的地址，加0也是数组首元素的地址。//利用规则3: 只要是地址就是4/8个字节//答案：4/8printf("%d\n", sizeof(*arr));//利用规则2:arr没有被单独放在sizeof内部，说明arr代表的是数组首元素的地址，对arr解引用是数组//首元素->字符类型—>1//答案:1printf("%d\n", sizeof(arr[1]));//利用规则2:arr没有被单独放在sizeof内部，说明arr代表的是数组首元素的地址，arr[1]是数组的//第二个元素->字符类型->1//答案：1printf("%d\n", sizeof(&arr));//利用规则1:&arr是取出了整个数组的地址，利用规则3:只要是地址就是4/8个字节//答案:4/8printf("%d\n", sizeof(&arr + 1));//利用规则1:&arr是取出了整个数组的地址，&arr+1跳过整个数组，利用规则3:只要是地址就是4/8个字节//答案:4/8printf("%d\n", sizeof(&arr[0] + 1));//利用规则2:这里的先与[]结合，arr[0]代表的是第一个数组的元素，对第一个数组元素取地址是第一个元素的地址//，加一是数组第二个元素的地址。利用规则3:只要是地址就是4/8个字节//答案:4/8return 0;
}

回顾:

char arr[] = {'a','b','c','d','e','f'};
printf("%d\n", sizeof(arr));
printf("%d\n", sizeof(arr+0));
printf("%d\n", sizeof(*arr));
printf("%d\n", sizeof(arr[1]));
printf("%d\n", sizeof(&arr));
printf("%d\n", sizeof(&arr+1));
printf("%d\n", sizeof(&arr[0]+1));

#include
int main()
{char arr[] = { 'a','b','c','d','e','f' };printf("%d\n", strlen(arr));//注意此arr是数组首元素的地址，类型匹配，但是数组内部的元素，没有\0,因此求出的是大于等于6的随机值//答案:大于等于6的随机值printf("%d\n", strlen(arr + 0));//arr+0还是数组首元素的地址，类型匹配，但是数组内部的元素，没有\0,因此求出的是大于等于6的随机值//答案:大于等于6的随机值printf("%d\n", strlen(*arr));//*arr对数组首元素地址解引用得到的是字符'a'——>97，类型不匹配，但是会被函数接收当做97的地址，内存//中有些空间是不能被访问的，所以会报错//答案:报错printf("%d\n", strlen(arr[1]));//arr[1]是数组的第二个元素字符'b'->98,与strlen类型不匹配，但是会被函数接收当做98的地址，内存//中有些空间是不能被访问的，所以会报错.printf("%d\n", strlen(&arr));//&arr取出的是整个数组的地址（与数组首元素的地址相同），与strlen类型不匹配，但是会被strlen识别为//数组首元素的地址，所以跟arr相同，但是数组内部的元素，没有\0,因此求出的是大于等于6的随机值//答案:大于等于6的随机值printf("%d\n", strlen(&arr+1));//&arr取出的是整个数组的地址（与数组首元素的地址相同），加1，跳过整个数组，与strlen类型不匹配，//但是会被strlen识别为,数组最后一个元素的下一个元素的地址，未知空间，因此求出的是随机值//答案:随机值printf("%d\n", strlen(&arr[0]+1));//arr先与[]结合表示的是，数组第一个元素，对数组第一个元素取地址再加1，得到的是数组第二个元素的地址//但是数组内部的元素，没有\0,因此求出的是大于等于5的随机值//答案:大于等于5的随机值return 0;
}

回顾:

char arr[] = "abcdef";
printf("%d\n", sizeof(arr));
printf("%d\n", sizeof(arr+0));
printf("%d\n", sizeof(*arr));
printf("%d\n", sizeof(arr[1]));
printf("%d\n", sizeof(&arr));
printf("%d\n", sizeof(&arr+1));
printf("%d\n", sizeof(&arr[0]+1));

#include
int main()
{char arr[] = "abcdef";printf("%d\n", sizeof(arr));//利用规则2，arr被单独放在sizeof内部表示的是整个元素的大小，注意字符串最后有个\0,所以是7个字符——>7//答案:7printf("%d\n", sizeof(arr+0));//利用规则2:arr没有被单独放在sizeof内部，arr+0表示的是数组首元素的地址，利用规则3，只要是地址就是4/8//答案:4/8printf("%d\n", sizeof(*arr));//利用规则2:arr没有被单独放在sizeof内部，*arr表示的是数组第一个元素，也就是字符类型——>1个字节//答案:1printf("%d\n", sizeof(arr[1]));//这里的arr[1]表示的数组第二个元素——‘b’——>类型为char->1字节//答案：1printf("%d\n", sizeof(&arr));//利用规则1:&arr指的是整个数组的地址，运用规则3，只要是地址就是4/8个字节//答案:4/8printf("%d\n", sizeof(&arr+1));//利用规则1:&arr指的是整个数组的地址，加1跳过了整个数组，运用规则3，只要是地址就是4/8个字节//答案:4/8printf("%d\n", sizeof(&arr[0]+1));//arr先与[0]结合表示的是第一个数组的元素，对数组的第一个元素取地址，表示的是数组首元素的地址，对数组//的首元素加1，表示的是数组第二个元素的地址，利用规则3：只要是地址就是4/8个字节//答案:4/8return 0;
}

回顾:

char arr[] = "abcdef";
printf("%d\n", sizeof(arr));
printf("%d\n", sizeof(arr+0));
printf("%d\n", sizeof(*arr));
printf("%d\n", sizeof(arr[1]));
printf("%d\n", sizeof(&arr));
printf("%d\n", sizeof(&arr+1));
printf("%d\n", sizeof(&arr[0]+1));

strlen（函数）的补充:
1.返回值为:size_t(unsigned int)
2.函数参数为const char * str
3.strlen求的只能数字符串长度，不带\0
4.strlen遇到\0就停止运算了
4.strlen数组名单独放在里面是数组首元素的地址(要跟sizeof区分开)

strlen的实现

#include 
#include 
size_t  my_strlen(const char*str)
{assert(str);char* ret = str;while (*str++){;} return (str - ret -1);
}

#include
int main()
{char arr[] = "abcdef";printf("%d\n", strlen(arr));//arr是数组首元素的地址，字符串的结尾是有\0的，所以最后求的结果是6//答案:6	printf("%d\n", strlen(arr+0));//arr+0是数组首元素的地址，字符串的结尾是有\0的，所以最后求的结果是6//答案：6printf("%d\n", strlen(*arr));//arr对数组首元素地址解引用得到的是字符'a'——>97，类型不匹配，但是会被函数接收当做97的地址，内存//中有些空间是不能被访问的，所以会报错。//答案:报错printf("%d\n", strlen(arr[1]));//arr[1]是数组的第二个元素字符'b'->98,与strlen类型不匹配，但是会被函数接收当做98的地址，内存//中有些空间是不能被访问的，所以会报错.//答案:报错printf("%d\n", strlen(&arr));//&arr取出的是整个数组的地址（与数组首元素的地址相同），与strlen类型不匹配，但是会被strlen识别为//数组首元素的地址，所以跟arr相同，所以求的是字符串的长度——6//答案：6printf("%d\n", strlen(&arr+1));//&arr取出的是整个数组的地址（与数组首元素的地址相同），加1，跳过整个数组，与strlen类型不匹配，//但是会被strlen识别为,数组最后一个元素的下一个元素的地址，未知空间，因此求出的是随机值//答案:随机值printf("%d\n", strlen(&arr[0]+1));//arr先与[]结合表示的是，数组第一个元素，对数组第一个元素取地址再加1，得到的是数组第二个元素的地址//所以求出的是从b开始数遇到\0停止，所以是5//答案:5return 0;
}

回顾:

printf("%d\n", strlen(arr));
printf("%d\n", strlen(arr+0));
printf("%d\n", strlen(*arr));
printf("%d\n", strlen(arr[1]));
printf("%d\n", strlen(&arr));
printf("%d\n", strlen(&arr+1));
printf("%d\n", strlen(&arr[0]+1));

三.字符指针

#include
int main()
{char *p = "abcdef";//说明:字符串返回的是字符串首元素的地址。printf("%d\n", sizeof(p));//p是指针就是4/8个字节//答案:4/8printf("%d\n", sizeof(p+1));//p+1是字符串第二个字符的地址，是地址就为4/8//答案:4/8printf("%d\n", sizeof(*p));//*p解引用得到的是第一个字符'a',大小为1个字节//答案:1printf("%d\n", sizeof(p[0]));//p[0]指的是字符串的第一个元素，'a',大小为1个字节//答案:1printf("%d\n", sizeof(&p));//对p取地址，得到的是p的地址，是地址就是4/8个字节//答案:4/8printf("%d\n", sizeof(&p+1));//对p取地址，得到的是p的地址，是地址就是4/8个字节//答案:4/8printf("%d\n", sizeof(&p[0]+1));//p[0]表示的是字符串的第一个元素'a',对字符串的第一个元素取地址，是字符串的第一个元素的地址，//+1是字符串第二个元素的地址，是地址就是4/8个字节//答案:4/8return 0;
}

回顾:

printf("%d\n", sizeof(p));
printf("%d\n", sizeof(p+1));
printf("%d\n", sizeof(*p));
printf("%d\n", sizeof(p[0]));
printf("%d\n", sizeof(&p));
printf("%d\n", sizeof(&p+1));
printf("%d\n", sizeof(&p[0]+1));

#include
int main()
{char *p = "abcdef";printf("%d\n", strlen(p));//p这里指的是指针也是字符串首元素的地址，所以求的是字符串的长度->6//答案:6printf("%d\n", strlen(p+1));//p+1这里指的是字符串第二个元素的地址，所以求的是从b开的长度->5//答案:5printf("%d\n", strlen(*p));//*p求的是第一个字符'a',这里的'a'是被放在变量中的，所以是1个字节//答案:1printf("%d\n", strlen(p[0]));//p[0]表示的是第一个字符‘a’,这里的'a'是被放在变量中的，所以是1个字节//答案:1printf("%d\n", strlen(&p));//&p指的是二级指针，也就是p的地址，所以传p的地址，得出的是随机数//答案:随机数printf("%d\n", strlen(&p+1));//&p指的是二级指针，也就是p的地址，然后对p的地址+1，所以传p+1的地址，得出的还是随机数//答案:随机数printf("%d\n", strlen(&p[0]+1));//p先与[0]结合，说明的p[0]指的是字符串的第一个元素，对字符串的第一个元素取地址相当于字符串首元素的地址//对首元素的地址+1得到的是第二个字符的地址，也就是从'b’往后数——长度为5//答案:5return 0;
}

回顾:

printf("%d\n", strlen(p));
printf("%d\n", strlen(p+1));
printf("%d\n", strlen(*p));
printf("%d\n", strlen(p[0]));
printf("%d\n", strlen(&p));
printf("%d\n", strlen(&p+1));
printf("%d\n", strlen(&p[0]+1));

四.二维数组

#include
int main()
{//二维数组int a[3][4] = {0};//表示的是三行四列的数组printf("%d\n",sizeof(a));//数组名单独放在sizeof内部表示的是整个数组，也就是12个整形，是48个字节//答案:48printf("%d\n",sizeof(a[0][0]));//a[0][0]表示的是第一个元素，类型为int，大小为4个字节printf("%d\n",sizeof(a[0]));//a[0]表示的第一行的数组名,数组名被单独放在sizeof内部指的是第一行的元素，//4个整形,大小为16个字节//答案:16printf("%d\n",sizeof(a[0]+1));//a[0],表示的是第一行的数组名，数组名没有别单独放在sizeof内部，a[0]表示的是//第一行第一个元素的地址，加1是第二个元素的地址，是地址就是4/8//答案:4/8printf("%d\n",sizeof(*(a[0]+1)));//a[0],表示的是第一行的数组名，数组名没有别单独放在sizeof内部，a[0]表示的是//第一行第一个元素的地址，加1是第二个元素的地址,对第一行第二个元素解引用得到//第一行第二个元素，类型为int ，大小为4//答案：4printf("%d\n",sizeof(a+1));//a没有被单独放在sizeof内部，二维数组的数组名表示的是数组第一行的地址，加1得到//第二行的地址，只要是地址就是4/8//答案：4/8printf("%d\n",sizeof(*(a+1)));//a没有被单独放在sizeof内部，二维数组的数组名表示的是数组第一行的地址，加1得到//第二行的地址，对第二行的地址进行解引用得到的是第二行第一个元素的地址，只要//是地址就是4/8个字节//答案：4/8printf("%d\n",sizeof(&a[0]+1));//a[0]是第一行的数组名，a[0]没有被单独放在sizeof内部，表示的是第一行第一个元素//的地址，对数组名取地址得到的是第一行的地址，加1是第二行的元素的地址，只要是地//址就是4/8//答案:4/8printf("%d\n",sizeof(*(&a[0]+1)));//a[0]是第一行的数组名，a[0]没有被单独放在sizeof内部，表示的是第一行第一个元素//的地址，对数组名取地址得到的是第一行的地址，加1是第二行的元素的地址，对第二行//地址解引用得到第二行第一个元素的地址，只要是地址就是4/8//答案:4/8printf("%d\n",sizeof(*a));//*a指的是对第一行的地址解引用得到的是数组第一个元素的地址，只要是地址就是4/8//答案:4/8printf("%d\n",sizeof(a[3]));//a[3]指的是第四行的数组名，数组名单独出现在sizeof内部表示的是第四行元素的大小//大小为4个整形->16字节//答案:4/8return 0;
}

回顾:

int a[3][4] = {0};
printf("%d\n",sizeof(a));
printf("%d\n",sizeof(a[0][0]));
printf("%d\n",sizeof(a[0]));
printf("%d\n",sizeof(a[0]+1));
printf("%d\n",sizeof(*(a[0]+1)));
printf("%d\n",sizeof(a+1));
printf("%d\n",sizeof(*(a+1)));
printf("%d\n",sizeof(&a[0]+1));
printf("%d\n",sizeof(*(&a[0]+1)));
printf("%d\n",sizeof(*a));
printf("%d\n",sizeof(a[3]));

五.指针笔试题

#include
int main()
{int a[5] = { 1, 2, 3, 4, 5 };int *ptr = (int *)(&a + 1);printf( "%d,%d", *(a + 1), *(ptr - 1));//看下面图解可得*（a+1）是2，*(ptr-1)就为5return 0;
}

图解:

struct Test
{
int Num;
char *pcName;
short sDate;
char cha[2];
short sBa[4];
}*p;
//假设p 的值为0x100000。 如下表表达式的值分别为多少？
//已知，结构体Test类型的变量大小是20个字节
int main()
{
printf("%p\n", p + 0x1);
//p+1跳过的是一个结构体的大小20个字节
//也就是0x100000+0x014
//答案: 0x00110014
printf("%p\n", (unsigned long)p + 0x1);
//p转换为unsigned long 加1就真的加一
//答案:0x00100001
printf("%p\n", (unsigned int*)p + 0x1);
//p的类型为unsigned int *加1跳过4个字节
//答案:0x00100004
return 0;
}

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);
//ptr[-1]相当于*(ptr-1)也就是4，((int)a+1)还跳过1个字节，由下图可知访问内存
//00 00 00 02小端存储->转换成16进制就是->02 00 00 00
//答案：4  2 00 00 00
return 0;
}

#include 
int main()
{int a[3][2] = { (0, 1), (2, 3), (4, 5) };//逗号表达式最后的结果为逗号表达式的最后一个值的结果，所以存的数为//1 3 //5 0 //0 0int *p;p = a[0];//是第一行的地址printf( "%d", p[0]);//访问的是第一个元素为:1return 0;
}

int main()
{int a[5][5];int(*p)[4];p = a;//注意a的类型为int(*)[5]printf( "%p,%d\n", &p[4][2] - &a[4][2], &p[4][2] - &a[4][2]);
//p[4][2]指的是第五行第3个元素（按每行四个来算），所以是第4*4+3=19个元素
//a[4][2]指的第第五行第3个元素（按每行5个计算），所以是5*4+3=23个
//对他们分别取地址，相减的绝对值是相差元素的个数，
// &p[4][2] - &a[4][2]:-4,用%p打印（补码）：
//1111 1111 1111 1111 1111 1111 1111 1100
//16进制:0xFF FF FF FC
//&p[4][2] - &a[4][2]，19-23=-4
//-4
//答案:0xFF FF FF FC   -4 return 0;
}

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));
//由图可知，ptr1-1可得是10的地址，a+1解引用是第二行第一个元素的地址，对ptr2-1
//是5的地址，对其解引用得到的是5.
//答案:10 5
return 0;
}

图解：

#include 
int main()
{char *a[] = {"work","at","alibaba"};char**pa = a;//一级指针数组的数组名用二级指针进行接收pa++;printf("%s\n", *pa);//由图可知打印的是at
return 0;
}

图解:

#include
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（前置++）解引用得到的是c+2，再解引用得到POINT首元素的地址//打印就是:POINTprintf("%s\n", *--*++cpp+3);//我们要注意上面的++对cpp已经产生了影响，所以再++cpp指的是c+1，所以对++cpp//解引用得到的是c+1，指的是NEW首元素的地址，再减减得到的是ENTER的地址//解引用得到的是ENTER首元素的地址，再加3得到的是E的地址。//所以最后为ERprintf("%s\n", *cpp[-2]+3);//这里再看cpp指向了c+1，但由于c+1在上一段代码已被更改成c，*(cpp-2）跟cpp[-2]//一样，所以指向的是c+3再解引用得到的是FIRST的首字母的地址，加3的到的是S的地址//解引用得到的是STprintf("%s\n", cpp[-1][-1]+1);//由于上面的cpp[-2]并没有更改cpp的值，所以这里的cpp指向c+1，但由于c+1在//上一段代码已被更改成c，因为cpp[-1][-1]可以解释为*(*(cpp-1)-1)cpp-1指的//是c+2，减1得到的是c+1解引用得到的是NEW的首字符的地址，加1得到的是E的地址，//所以最后为EWreturn 0;
}

图解: