知识简单回顾
指针是什么
内存 ->内存的单元（1byte）->编号->地址
我们有一块很大的内存空间，内存空间被分为一个一个的单元，一个内存单元的大小是1byte(字节)，每个字节都有它的编号，这个编号就是地址，地址又叫做指针。
指针就是一个地址。
我们口头语说的指针一般指：指针变量
指针变量就是一个变量，就是一块内存空间，指针变量用来存放地址。
&a就是内存的编号，也是地址.
这个指针变量叫做pa,int*是类型（整形指针），通过这个类型创造的变量叫做pa。
*pa就是对pa进行解引用，通过pa存放的地址找到它所指向的对象（a）,pa存的是a的地址所以pa指向a,*pa其实就是a。
*pa = 20；就相当于 a = 20；将 a 的值改变了。
int main() { int a = 0; int* pa = &a; *pa = 20; return 0; }
指针变量的大小？
——4/8个字节，取决于编译器是x86环境还是x64环境
指针类型的意义
两件事情：
1.指针类型进行+1/-1的操作时，它会跳过几个字节。
2.进行解引用操作的时候，决定了解引用操作时候的权限，（访问多少个字节）
指针的运算
1。+-整数
2.指针-指针
3.指针的关系运算
指针数组
本质上就是数组，数组中存放的是指针（地址）。
arr 存放了三个元素，每个元素都是int*类型，也就是指针，那么arr就是指针数组。
int main() { int *pa; int *pb; int *pc; int* arr = { pa,pb,pc }; return 0; }
数组名是什么
1.数组名在大部分情况下表示数组首元素的地址，
但是有两个例外：
a）sizeof（数组名），表示的是整个数组的大小
b）&数组名，取出的是整个数组的地址
数组指针
&数组名，这里的parr ,存放的是数组的地址，parr为数组指针。
数组指针：int (*parr)[10]，parr与*结合，代表parr为指针，[10]表示parr指向数组，数组中元素的类型是int。
指针数组：int* parr[10],没有括号，parr与[10]结合，表示parr为数组，数组中元素的类型是int*(整形指针)
数组指针类型的表示：int (*)[10];
int arr[10] = {1,2,3}; int (*parr)[10] = &arr;
函数指针
函数指针就是函数的地址，函数也有地址，我们可以通过函数的地址去使用函数。
函数的地址存放在函数指针变量中，
函数指针类型表示：
int (*)(int,int)
int(*pf)(int ,int)，pf与*结合，表示pf是指针，指针指向的是(int , int)参数是两个整形的函数，函数的返回类型是int。
int Add(int x,int y) { return x + y; } int main() { int (*pf)(int ,int) = &Add; int sum = (*pf)(2,3); //Add 和 &函数名一样，Add也可以直接表示为地址,因此也可以写成这种形式 //int (*pf)(int ,int) = Add; //Add传给了pf，pf 等同于 Add ,那么我们也可以这样写。 //int sum = pf(2.3) return 0; }
函数指针数组
存放函数指针的数组。
我们将函数指针数组命名为arr，arr数组的每个元素的类型是：int (*)(int,int)
函数指针数组的类型表示：
int （*[4])(int,int)
怎么理解这函数指针数组的形式？
arr与[4]结合，说明arr是数组，这个数字的每个元素是int(*)(int,int),而这正好是函数指针类型。
int （*arr[4])(int,int) = {Add,Sub,Div,Mul};
回调函数
通过函数指针调用的函数就是回调函数。
这里的函数指针是pf，pf指向的函数是Add，通过pf调用Add，我们称Add为回调函数。
int Add(int x,int y) { return x + y; } int main() { int (*pf)(int ,int) = Add; int sum = pf(2.3); return 0; }
笔试题
一维数组
题目：
以下打印的结果分别是什么？
int a[] = {1,2,3,4}; 1|printf("%d\n",sizeof(a)); 2|printf("%d\n",sizeof(a+0)); 3|printf("%d\n",sizeof(*a)); 4|printf("%d\n",sizeof(a+1)); 5|printf("%d\n",sizeof(a[1])); 6|printf("%d\n",sizeof(&a)); 7|printf("%d\n",sizeof(*&a)); 8|printf("%d\n",sizeof(&a+1)); 9|printf("%d\n",sizeof(&a[0])); 10|printf("%d\n",sizeof(&a[0]+1));
数组名的理解，指针的运算和指针类型的意义
解析：
1.printf (" %d\n ", sizeof ( a ) ); 16
sizeof(数组名），数组名表示整个数组，计算的是整个数组的大小，单位是字节
2.printf (" %d\n ", sizeof( a+0 ) ); 4 / 8
a不是单独放在sizeof内部，也没有取地址，所以a就是首元素的地址，a+0还是首元素的地址。是地址，大小就是4 / 8个字节。地址的大小和环境有关，32位的系统环境就是4个字节，64位系统环境就是8个字节。
3.printf (" %d\n ", sizeof( *a ) ); 4
*a中的a是数组数组首元素的地址，*a就是对首元素的地址解引用，找到的就是首元素，
首元素是整形，所占内存大小是4个字节
4.printf (" %d\n ", sizeof( a+1 ) ); 4 / 8
a不是单独放在sizeof的内部，a表示的是首元素的地址，a+1就是数组第二个元素的地址
地址的大小是4个字节或者8个字节。
5.printf (" %d\n ", sizeof( a[1] ) ); 4
a[1]表示的是数组的第二个元素，作为整形元素的大小为4个字节
6.printf (" %d\n ", sizeof( &a ) ); 4 / 8
&a,&数组名，这里的a表示的是整个数组的地址，一共4个元素，地址的大小是4个字节。虽然说是整个数组的地址，但是还是通过首元素的地址来表达。
注意：首元素的地址和数组的地址虽然表现是同一个地址，但是它们的运算的结果是不一样的。
比如：&a+1和a+1,一个表示的是跳过了一个（4个整形元素的）数组的地址，一个表示的是数组第二个元素的地址
7.printf (" %d\n ", sizeof( *&a ) ); 16
&a取的是整个数组的地址，对&a进行解引用，得到的是整个数组，一共4个元素，一个整形元素的大小为4个字节，一共是16个字节
8.printf (" %d\n ", sizeof( &a+1 ) ); 4 / 8
&数组名，取的是整个数组的地址，&a再加上1，就是跳过一个数组的位置，然后再取了一个相同大小数组的地址。&a+1还是地址，地址的大小就是4 / 8个字节。
9.printf (" %d\n ", sizeof( &a[0] ) ); 4 / 8
&a[0]取的是数组第一个元素的地址，大小是4个字节或者8个字节。
10.printf (" %d\n ", sizeof( &a[0]+1 ) ); 4 / 8
&a[0],取的是数组第一个元素的地址，&a[0]+1就是数组第二个元素的地址。大小是4个字节或者8个字节。
总结：
1.数组名大多数表示首元素的地址，有两个例外：1.sizeof（数组名）2.&数组名。数组名表示的是整个数组 。
2.不同类型地址跳过的字节不一样，&a+1，&a表示的是整个数组，+1就会跳过一个数组的大小。&a[0]+1,&a[0]是数组第一个元素的地址，所以+1跳过的是一个元素的大小。
3.地址意义可能不同，但是地址的大小都是4 / 8个字节。
字符数组
题目1：
以下打印的结果是什么？
char arr[] = {'a','b','c','d','e','f'}; 1|printf("%d\n",sizeof(arr)); 2|printf("%d\n",sizeof(arr+0)); 3|printf("%d\n",sizeof(*arr)); 4|printf("%d\n",sizeof(arr[1])); 5|printf("%d\n",sizeof(&arr)); 6|printf("%d\n",sizeof(&arr+1)); 7|printf("%d\n",sizeof(&arr[0]+1));
解析：
1| printf (" %d\n " , sizeof ( arr ) ) 6
sizeof(数组名)，取的是整个数组的大小，字符数组arr一共6个元素，所以大小为6个字节。
2|printf (" %d\n ", sizeof( arr+0 ) ) 4 / 8
arr并没有单独放在sizeof内部，所以arr表示首元素的地址，arr+0也表示首元素的地址。是地址，那么大小就为4个字节或者8个字节。
3|printf (" %d\n ",sizeof ( *arr ) ) 1
arr是首元素的地址，就是 ‘a’ 的地址，然后解引用，就是‘a’，char类型，大小是1个字节。
*arr 等价于arr [ 0 ]
*(arr+0) 等价于 arr [ 0 ]
4|printf (" %d\n ", sizeof( arr[1] ) ) 1
arr[1]是数组第二个元素，‘b'，大小是1个字节。
5|printf (" %d\n ", sizeof( &arr ) ) 4 / 8
&arr取的是数组的地址，是地址就是4 / 8 个字节。
6|printf (" %d\n ", sizeof( &arr+1 ) ) 4 / 8
&arr取的是arr数组的地址，&arr+1跳过一个（6个字符元素的）数组，下图是&arr+1的地址位置，是地址，大小就是4个字节或者8个字节。
7|printf (" %d\n ", sizeof( &arr[0]+1 ) ) 4 / 8
&arr[0]取的是数组第一个元素的地址，&arr[0]+1就是第二个元素的地址，是地址，就是4个字节或者8个字节。
题目2：
以下的打印结果分别是什么？
char arr[] = {'a','b','c','d','e','f'}; 1|printf("%d\n",strlen(arr)); 2|printf("%d\n",strlen(arr+0)); 3|printf("%d\n",strlen(*arr)); 4|printf("%d\n",strlen(arr[1])); 5|printf("%d\n",strlen(&arr)); 6|printf("%d\n",strlen(&arr+1)); 7|printf("%d\n",strlen(&arr[0]+1));
解析：
strlen
用来求字符串长度的库函数，参数是地址，从参数传来的地址开始，直到有' \0 '停止。
1|printf (" %d\n ", strlen ( arr ) ) 随机值
arr为数组首元素的地址，字符数组没有' \0 ',strlen会运行完数组，还会继续运行，直到遇到' \0',但是数组外的元素不由数组控制，也就是说，' \0 '什么时候出现是不可知的，所以会打印随机值。
下图遇到' \0 '前一共19个元素，所以打印结果为19。
' \0 '的ASCII的数字就是0.
2|printf (" %d\n ", strlen ( arr+0 ) ) 随机值
arr+0也是首元素的地址，其实和前面问题的随机值是一样的。这里也将会在第20个元素遇到 ‘\0’，所以这里的随机值与 1| 一样。
3|printf (" %d\n ", strlen ( *arr ) ) 访问冲突
strlen的参数是地址，而*arr传过去的是 ’a‘ ，’a'的ASCII值为97，，不是一个地址，就会发生访问冲突，也就是野指针问题。
4|printf (" %d\n ", strlen ( arr[1] ) ) 访问冲突
和前面一个问题产生的结果一样，既然strlen函数的参数是地址，将值传过去就会产生野指针的问题。
5|printf (" %d\n ", strlen ( &arr ) ) 随机值
&arr传过去的是整个数组的地址，strlen用const char* str来接收，那么strlen又是怎么运行的呢？这里的地址和1|、2|类型不同，但是地址的位置是相同的，strlen也应该是从首元素开始一个一个筛查，直到遇到 ‘\0’ ，求字符串才算结束。所以这里和1|、2|的结果应该是一样的。
6|printf (" %d\n ", strlen ( &arr+1 ) ) 随机值 - 6
&arr+1，&arr取的是整个数组的地址，&arr+1会跳过一个（6个char类型元素的）数组，下图标记&arr+1的地址位置，strlen函数也就是从这里开始运行，直到遇到 ‘\0’ ,那么这里的结果就会比1|、2|、5|的结果少6个元素。结果：随机值 - 6
7|printf (" %d\n ", strlen ( &arr[0]+1 ) ) 随机值 - 1
&arr[0]取的是数组第一个元素的地址，&arr[0]+1就是数组第二个元素的地址，从第二个元素开始，strlen遇到 '\0' 停止，就会比1|、2|、5|的结果少1个元素。结果：随机值 - 1.
总结：
1.strlen（const char* str）传递的参数是地址，如果传递数值的话，就会产生访问冲突的问题。
2.strlen不管地址的类型，只管地址的位置，从地址的位置开始，逐个去数字符，直到遇到 \0 ,strlen就停止运行，求出字符串的长度。
题目3：
以下打印的结果是什么？
char arr[] = "abcdef"; 1|printf("%d\n",sizeof(arr)); 2|printf("%d\n",sizeof(arr+0)); 3|printf("%d\n",sizeof(*arr)); 4|printf("%d\n",sizeof(arr[1])); 5|printf("%d\n",sizeof(&arr)); 6|printf("%d\n",sizeof(&arr+1)); 7|printf("%d\n",sizeof(&arr[0]+1));
解析：
char arr[] = "abcdef",这个数组的元素为[ a b c d e f \0 ],一共7个元素，字符串默认以 \0 结尾。
1|printf (" %d\n ", sizeof ( arr ) ) 7
sizeof(数组名)，这里的数组名表示的是整个数组，因为字符串默认为 ‘\0’ 结尾，所以这个数组有7个元素，结果为7个字节。
2|printf (" %d\n ", sizeof ( arr+0 ) ) 4 / 8
arr表示的是首元素的地址，arr+0表示首元素的地址，是地址，地址的大小为4个字节或者8个字节。
3|printf (" %d\n ", sizeof ( *arr ) ) 1
arr表示首元素的地址，*arr取的是‘a’,大小为1个字节。
4|printf (" %d\n ", sizeof ( arr[1] ) ) 1
arr[1]为数组的第二个元素，‘b’，大小为1个字节。
5|printf (" %d\n ", sizeof ( &arr ) ) 4 / 8
&arr取的是整个数组的地址，地址的大小为4个字节或者8个字节。
6|printf (" %d\n ", sizeof ( &arr+1 ) ) 4 / 8
&arr取的是整个数组的地址，&arr+1跳过1个（7个元素）的数组，跳过一个数组，但是地址的类型是不变的，是还是一个数组的地址，不过既然是地址，地址的大小为4个字节或者8个字节。
7|printf (" %d\n ", sizeof ( &arr[0]+1 ) ) 4 / 8
&arr[0]取的是数组第一个元素的地址，&arr+1就是数组第二个元素的地址，地址的大小为4个字节或者8个字节。
总结：
1.不管地址的类型是什么，只要是地址，地址的大小就是4个字节或者8个字节。
2.字符串相当于普通的字符数组，但是字符串通常默认 \0 为结尾。
3.sizeof 只关注占用内存空间的大小，不在乎内存中放的是什么。
题目4：
以下打印的结果是什么？
char arr[] = "abcdef"; 1|printf("%d\n",strlen(arr)); 2|printf("%d\n",strlen(arr+0)); 3|printf("%d\n",strlen(*arr)); 4|printf("%d\n",strlen(arr[1])); 5|printf("%d\n",strlen(&arr)); 6|printf("%d\n",strlen(&arr+1)); 7|printf("%d\n",strlen(&arr[0]+1));
解析：
char arr[] = "abcdef",这个数组的元素为[ a b c d e f \0 ],一共7个元素，字符串默认以 \0 结尾。
strlen是求字符串长度的，关注的是字符串中的 \0 ，计算的是 \0 之前出现的字符的个数。
1|printf (" %d\n" , strlen ( arr ) ) 6
arr是首元素的地址，遇到 \0 停止。结果：6
2|printf (" %d\n ", strlen ( arr+0 ) ) 6
3|printf (" %d\n ", strlen ( *arr ) ) 访问冲突
传递的不是地址。
4|printf (" %d\n ", strlen ( arr[1] ) ) 访问冲突
传递的不是地址。
5|printf (" %d\n ", strlen ( &arr ) ) 6
取的是整个数组的地址，但是地址位置是首元素的地址。
6|printf (" %d\n ", strlen ( &arr+1 ) ) 随机值
跳过了一个数组，\0也包括在这个数组里面，strlen就会往下去寻找 \0 ,结果会是随机值。
7|printf (" %d\n ", strlen ( &arr[0]+1 ) ) 5
从第二个元素开始，后面遇到 \0,一共是5个元素。
总结：
1. strlen是求字符串长度的，关注的是字符串中的 \0 ，计算的是 \0 之前出现的字符的个数。
2.sizeof 只关注占用内存空间的大小，不在乎内存中放的是什么。
题目5：
char* p = "abcdef"; 1|printf("%d\n",sizeof(p)); 2|printf("%d\n",sizeof(p+1)); 3|printf("%d\n",sizeof(*p)); 4|printf("%d\n",sizeof(p[0])); 5|printf("%d\n",sizeof(&p)); 6|printf("%d\n",sizeof(&p+1)); 7|printf("%d\n",sizeof(&p[0]+1));
答案：
这里的“abcdef”并不是数组，而是常量字符串，常量字符串在内存中有独立的地址。p接收的是首元素’a‘的地址。
1|printf (" %d\n ", sizeof ( p ) ) 4 / 8
p是 指针变量，存放的是’a‘的地址。地址的大小为4个字节或者8个字节。
2|printf (" %d\n ", sizeof ( p+1 ) ) 4 / 8
p+1是地址。
3|printf (" %d\n ", sizeof ( *p ) ) 1
*p是 ’a‘，大小是1个字节
4|printf (" %d\n ", sizeof ( p[0] ) ) 1
p[0]是’a‘，大小是1个字节。
5|printf (" %d\n ", sizeof ( &p ) ) 随机值
&p是地址，p是指针变量，p存放的是常量字符串首元素’a‘的地址，但是p的地址与常量字符串没有关系，p的地址属于二级指针，一级指针的地址。所以是随机值。
6|printf (" %d\n ", sizeof ( &p+1 ) ) 4 / 8
&p+1是地址。所以大小为4个字节或者8个字节。
7|printf (" %d\n ", sizeof ( &p[0]+1 ) ) 4 / 8
&p[0]+1是地址。&p[0]就是‘a’的地址，+1就是‘b’的地址。
题目6：
char* p = "abcdef"; 1|printf("%d\n",strlen(p)); 2|printf("%d\n",strlen(p+1)); 3|printf("%d\n",strlen(*p)); 4|printf("%d\n",strlen(p[0])); 5|printf("%d\n",strlen(&p)); 6|printf("%d\n",strlen(&p+1)); 7|printf("%d\n",strlen(&p[0]+1));
答案：
1|printf (" %d\n ", strlen( p ) ) 6
p是首元素‘a’的地址，往后6个元素，到 \0 停止。
2|printf (" %d\n ", strlen( p+1 ) ) 5
p+1是第二个元素的地址，往后5个元素，到 \0 停止。
3|printf (" %d\n ", strlen ( *p ) ) 访问冲突
strlen的参数为地址。
4|printf (" %d\n ", strlen ( p[0] ) ) 访问冲突
strlen的参数为地址。
5|printf (" %d\n ", strlen ( &p ) ) 随机值
p是一级指针，&p就是二级指针。p的地址和常量字符串“abcdef”没有关系。
6|printf (" %d\n ", strlen( &p+1 ) ) 随机值 - 1
&p取的是p的地址，&p指向p的下一位。
7|printf (" %d\n ", strlen ( &p[0]+1 ) ) 5
p[0]就是’a‘,&p[0]取出了’a‘的地址，&p[0]+1就是’b‘的地址。
strlen从’b‘开始往后数，一直数到 \0为止，一共是5个元素。
