一. 一维数组
首先说明：需熟记以下三个规则。
规则1.&数组名指的是取出整个数组的地址。
规则2.数组名被单独放在sizeof内部，计算的是整个数组的大小。
说明：这里的单独指的是不参与运算，如果不单独，按数组首元素的地址进行计算。
规则3.只要是地址的大小，就是4/8个字节（32位——X86，是4个字节,64位上是8个字节）
注意：
1.sizeof的返回值是 unsigned int
2.sizeof是操作符也是关键字，但不是函数。
3.sizeof在预编译的时候就已经处理好了，调试是看不到求解过程的！
#include<stdio.h>
int main()
{
//一维数组
int a[] = {
1,2,3,4};
printf("%d\n",sizeof(a));
//运用规则1，我们知道这里的a是整个数组的大小——>4个整形——>16个字节
//所以答案是：16
printf("%d\n",sizeof(a+0));
//运用规则2,a不是被单独放在sizeof内部，所以里的a是数组首元素的的地址，
//再运用规则3，可知地址在32位——4,64位——8，所以答案是4/8
printf("%d\n",sizeof(*a));
//*a运用规则2，这里的a不是单独出现，所以是数组首元素的地址，对数组首元素地址解引用
//得出*a是数组首元素——1——>类型为int——>4个字节
//答案：4
printf("%d\n",sizeof(a+1));
//运用规则2,a不是被单独放在sizeof内部，所以里的a是数组首元素的的地址，
//a+1得到的是数组第二个元素的地址
//再运用规则3，可知地址在32位——4,64位——8，
//答案是4/8
printf("%d\n",sizeof(a[1]));
//运用规则2，这里的a不是单独出现，所以是数组首元素的地址，这里表示的是数组的第
//二个元素——2——>类型为int——>大小为4个字节
//答案是：4
printf("%d\n",sizeof(&a));
//运用规则1,这里的&a表示的整个数组的大小，再运用规则3，只要是地址，大小就为4或
//8个字节
//答案是:4/8
printf("%d\n",sizeof(*&a));
//运用规则1：这里&a得到的是整个数组的地址，对整个数组的地址解引用，得到的为数组
//名，运用规则2：数组名在sizeof内部是整个数组的大小——>4个整形->16个字节
//答案:16
printf("%d\n",sizeof(&a+1));
//运用规则1：这里的&a指的是整个数组的地址，对整个数组加一跳过的是一个数组的大小
//也就是跳过了4个整形(16个字节)，但结果还是数组指针的类型——>地址——>运用规则3，
//可知地址在32位——4,64位——8
//答案是:4/8
//说明:这里的+1之后得到的是野指针，但是我们只是计算，并不访问和修改
//所以是没有问题的
printf("%d\n", sizeof(&a[0]));
//a首先与[]结合([]的优先级大于&)得到是数组第一个元素，对数组的元素取地址得到的
//第一个元素的地址，是地址——>运用规则3->地址为4或8个字节
//答案:4/8
printf("%d\n",sizeof(&a[0]+1));
//a首先与[]结合([]的优先级大于&)得到是数组第一个元素，对数组的元素取地址得到的
//第一个元素的地址,对第一个元素的地址加一，得到的是第二个元素的地址是地址——>
//运用规则3->地址为4或8个字节
//答案:4/8个字节
return 0;
}
到这里我们的一维数组就讲完了，再看看下面的代码思考一下，是否豁然开朗？
#include<stdio.h>
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<stdio.h>
int main()
{
char arr[] = {
'a','b','c','d','e','f' };
printf("%d\n", sizeof(arr));
//利用规则2：arr被单独放在sizeof内部，说明arr代表的是整个数组->6个字符->6字节
//答案:6
printf("%d\n", sizeof(arr + 0));
//利用规则2：arr没有被单独放在sizeof内部，说明arr代表的是数组首元素的地址，加0也是数组首元素的地址。
//利用规则3: 只要是地址就是4/8个字节
//答案：4/8
printf("%d\n", sizeof(*arr));
//利用规则2:arr没有被单独放在sizeof内部，说明arr代表的是数组首元素的地址，对arr解引用是数组的
//首元素->字符类型—>1
//答案:1
printf("%d\n", sizeof(arr[1]));
//利用规则2:arr没有被单独放在sizeof内部，说明arr代表的是数组首元素的地址，arr[1]是数组的
//第二个元素->字符类型->1
//答案：1
printf("%d\n", sizeof(&arr));
//利用规则1:&arr是取出了整个数组的地址，利用规则3:只要是地址就是4/8个字节
//答案:4/8
printf("%d\n", sizeof(&arr + 1));
//利用规则1:&arr是取出了整个数组的地址，&arr+1跳过整个数组，利用规则3:只要是地址就是4/8个字节
//答案:4/8
printf("%d\n", sizeof(&arr[0] + 1));
//利用规则2:这里的先与[]结合，arr[0]代表的是第一个数组的元素，对第一个数组元素取地址是第一个元素的地址
//，加一是数组第二个元素的地址。利用规则3:只要是地址就是4/8个字节
//答案:4/8
return 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));
strlen（函数）的补充:
1.返回值为:size_t(unsigned int)
2.函数参数为const char * str
3.strlen求的只能数字符串长度，不带\0
4.strlen遇到\0就停止运算了
4.数组名单独放在strlen里面是数组首元素的地址(要跟sizeof区分开)
strlen的实现
#include <stdio.h>
#include <assert.h>
size_t my_strlen(const char*str)
{
assert(str);
char* ret = str;
while (*str++)
{
;
}
return (str - ret -1);
}
#include<stdio.h>
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", 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<stdio.h>
int main()
{
char arr[] = "abcdef";
printf("%d\n", sizeof(arr));
//利用规则2，arr被单独放在sizeof内部表示的是整个元素的大小，注意字符串最后有个\0,所以是7个字符——>7
//答案:7
printf("%d\n", sizeof(arr+0));
//利用规则2:arr没有被单独放在sizeof内部，arr+0表示的是数组首元素的地址，利用规则3，只要是地址就是4/8
//答案:4/8
printf("%d\n", sizeof(*arr));
//利用规则2:arr没有被单独放在sizeof内部，*arr表示的是数组第一个元素，也就是字符类型——>1个字节
//答案:1
printf("%d\n", sizeof(arr[1]));
//这里的arr[1]表示的数组第二个元素——‘b’——>类型为char->1字节
//答案：1
printf("%d\n", sizeof(&arr));
//利用规则1:&arr指的是整个数组的地址，运用规则3，只要是地址就是4/8个字节
//答案:4/8
printf("%d\n", sizeof(&arr+1));
//利用规则1:&arr指的是整个数组的地址，加1跳过了整个数组，运用规则3，只要是地址就是4/8个字节
//答案:4/8
printf("%d\n", sizeof(&arr[0]+1));
//arr先与[0]结合表示的是第一个数组的元素，对数组的第一个元素取地址，表示的是数组首元素的地址，对数组
//的首元素加1，表示的是数组第二个元素的地址，利用规则3：只要是地址就是4/8个字节
//答案:4/8
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<stdio.h>
int main()
{
char arr[] = "abcdef";
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相同，所以求的是字符串的长度——6
//答案：6
printf("%d\n", strlen(&arr+1));
//&arr取出的是整个数组的地址（与数组首元素的地址相同），加1，跳过整个数组，与strlen类型不匹配，
//但是会被strlen识别为,数组最后一个元素的下一个元素的地址，未知空间，因此求出的是随机值
//答案:随机值
printf("%d\n", strlen(&arr[0]+1));
//arr先与[]结合表示的是，数组第一个元素，对数组第一个元素取地址再加1，得到的是数组第二个元素的地址
//所以求出的是从b开始数遇到\0停止，所以是5
//答案:5
return 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<stdio.h>
int main()
{
char *p = "abcdef";
//说明:字符串返回的是字符串首元素的地址。
printf("%d\n", sizeof(p));
//p是指针就是4/8个字节
//答案:4/8
printf("%d\n", sizeof(p+1));
//p+1是字符串第二个字符的地址，是地址就为4/8
//答案:4/8
printf("%d\n", sizeof(*p));
//*p解引用得到的是第一个字符'a',大小为1个字节
//答案:1
printf("%d\n", sizeof(p[0]));
//p[0]指的是字符串的第一个元素，'a',大小为1个字节
//答案:1
printf("%d\n", sizeof(&p));
//对p取地址，得到的是p的地址，是地址就是4/8个字节
//答案:4/8
printf("%d\n", sizeof(&p+1));
//对p取地址，得到的是p的地址，是地址就是4/8个字节
//答案:4/8
printf("%d\n", sizeof(&p[0]+1));
//p[0]表示的是字符串的第一个元素'a',对字符串的第一个元素取地址，是字符串的第一个元素的地址，
//+1是字符串第二个元素的地址，是地址就是4/8个字节
//答案:4/8
return 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<stdio.h>
int main()
{
char *p = "abcdef";
printf("%d\n", strlen(p));
//p这里指的是指针也是字符串首元素的地址，所以求的是字符串的长度->6
//答案:6
printf("%d\n", strlen(p+1));
//p+1这里指的是字符串第二个元素的地址，所以求的是从b开的长度->5
//答案:5
printf("%d\n", strlen(*p));
//*p求的是第一个字符'a',这里的'a'是被放在变量中的，所以是1个字节
//答案:1
printf("%d\n", strlen(p[0]));
//p[0]表示的是第一个字符‘a’,这里的'a'是被放在变量中的，所以是1个字节
//答案:1
printf("%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
//答案:5
return 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<stdio.h>
int main()
{
//二维数组
int a[3][4] = {
0};
//表示的是三行四列的数组
printf("%d\n",sizeof(a));
//数组名单独放在sizeof内部表示的是整个数组，也就是12个整形，是48个字节
//答案:48
printf("%d\n",sizeof(a[0][0]));
//a[0][0]表示的是第一个元素，类型为int，大小为4个字节
printf("%d\n",sizeof(a[0]));
//a[0]表示的第一行的数组名,数组名被单独放在sizeof内部指的是第一行的元素，
//4个整形,大小为16个字节
//答案:16
printf("%d\n",sizeof(a[0]+1));
//a[0],表示的是第一行的数组名，数组名没有别单独放在sizeof内部，a[0]表示的是
//第一行第一个元素的地址，加1是第二个元素的地址，是地址就是4/8
//答案:4/8
printf("%d\n",sizeof(*(a[0]+1)));
//a[0],表示的是第一行的数组名，数组名没有别单独放在sizeof内部，a[0]表示的是
//第一行第一个元素的地址，加1是第二个元素的地址,对第一行第二个元素解引用得到
//第一行第二个元素，类型为int ，大小为4
//答案：4
printf("%d\n",sizeof(a+1));
//a没有被单独放在sizeof内部，二维数组的数组名表示的是数组第一行的地址，加1得到
//第二行的地址，只要是地址就是4/8
//答案：4/8
printf("%d\n",sizeof(*(a+1)));
//a没有被单独放在sizeof内部，二维数组的数组名表示的是数组第一行的地址，加1得到
//第二行的地址，对第二行的地址进行解引用得到的是第二行第一个元素的地址，只要
//是地址就是4/8个字节
//答案：4/8
printf("%d\n",sizeof(&a[0]+1));
//a[0]是第一行的数组名，a[0]没有被单独放在sizeof内部，表示的是第一行第一个元素
//的地址，对数组名取地址得到的是第一行的地址，加1是第二行的元素的地址，只要是地
//址就是4/8
//答案:4/8
printf("%d\n",sizeof(*(&a[0]+1)));
//a[0]是第一行的数组名，a[0]没有被单独放在sizeof内部，表示的是第一行第一个元素
//的地址，对数组名取地址得到的是第一行的地址，加1是第二行的元素的地址，对第二行
//地址解引用得到第二行第一个元素的地址，只要是地址就是4/8
//答案:4/8
printf("%d\n",sizeof(*a));
//*a指的是对第一行的地址解引用得到的是数组第一个元素的地址，只要是地址就是4/8
//答案:4/8
printf("%d\n",sizeof(a[3]));
//a[3]指的是第四行的数组名，数组名单独出现在sizeof内部表示的是第四行元素的大小（虽然没有但是可以计算）
//大小为4个整形->16字节
//答案:4/8
return 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<stdio.h>
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)就为5
return 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
//答案: 0x00 11 00 14
printf("%p\n", (unsigned long)p + 0x1);
//p转换为unsigned long 加1就真的加一
//答案:0x00 10 00 01
printf("%p\n", (unsigned int*)p + 0x1);
//p的类型为unsigned int *加1跳过4个字节
//答案:0x00 10 00 04
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 ， 02 00 00 00
return 0;
}
#include <stdio.h>
int main()
{
int a[3][2] = {
(0, 1), (2, 3), (4, 5) };
//逗号表达式最后的结果为逗号表达式的最后一个值的结果，所以存的数为
//1 3
//5 0
//0 0
int *p;
p = a[0];//是第一行的地址
printf( "%d", p[0]);
//访问的是第一个元素为:1
return 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 <stdio.h>
int main()
{
char *a[] = {
"work","at","alibaba"};
char**pa = a;
//一级指针数组的数组名用二级指针进行接收
pa++;
printf("%s\n", *pa);
//由图可知打印的是at
return 0;
}
图解:
#include<stdio.h>
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首元素的地址
//打印就是:POINT
printf("%s\n", *--*++cpp+3);
//我们要注意上面的++对cpp已经产生了影响，所以再++cpp指的是c+1，所以对++cpp
//解引用得到的是c+1，指的是NEW首元素的地址，再减减得到的是ENTER的地址
//解引用得到的是ENTER首元素的地址，再加3得到的是E的地址。
//所以最后为ER
printf("%s\n", *cpp[-2]+3);
//这里再看cpp指向了c+1，但由于c+1在上一段代码已被更改成c，*(cpp-2）跟cpp[-2]
//一样，所以指向的是c+3再解引用得到的是FIRST的首字母的地址，加3的到的是S的地址
//解引用得到的是ST
printf("%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的地址，
//所以最后为EW
return 0;
}
细节:++会产生后置影响，也就是会更改原来的值。
图解:
