C语言深度解剖读书笔记

指针这一节是本书中最难的一节，尤其是二级指针和二维数组直接的关系。

本节知识点：

1.指针基础，一张图说明什么是指针：

2.跨过指针，直接去访问一块内存：

    只要你能保证这个地址是有效的 ，就可以这样去访问一个地址的内存*((unsigned int *)(0x0022ff4c))=10;  但是前提是 0x0022ff4c是有效地址。对于不同的编译器这样的用法还不一样，一些严格的编译器，当你定义一个指针，把这个指针赋值为一个这样的地址的时候，当检测到地址无效，编译的时候就会报错！！！如果一些不太严格的编译器，不管地址有效无效都会编译通过，但是对于无效地址，当你访问这块地址的时候，程序就会运行停止！

3.a     &a    &a[0]三者的区别：

首先说三者的值是一样的，但是意义是不一样的。(这里仅仅粗略的说说，详细见文章<c语言中数组名a和&a>)

     &a[0]：这个是数组首元素的地址

     a ： 的第一个意义是 数组首元素的地址，此时与&a[0]完全相同
                第二个意义是 数组名  sizeof(a)  为整体数组有多少个字节

    &a ：这个是数组的地址 。跟a的区别就是，a是一个 int* 的指针(在第一种意义的时候) ，而&a是一个 int (*p)[5]类型的数组指针，指针运算的结果不一样。(此处的int* 仅仅是为了举例子，具体应该视情况而定)

4.指针运算(本节最重要的知识点，但并不是最难的，所以的问题都来源于这儿)：   

   对于指针的运算，首先要清楚的是指针类型(在C语言中，数据的类型决定数据的行为)，然后对于加减其实就是对这个指针的大小加上或者减去，n*sizeof(这个指针指向的数据的类型)。即：一个类型为T的指针的移动，是以sizeof(T)为单位移动的。如：int* p;  p+1就是p这个指针的值加上sizeof(int)*1，即：(unsigned int)p + sizeof(int)*1。对于什么typedef的，struct的，数组的都是一样的。

这个有一个例子，代码如下：

[cpp] view plaincopy

1. #include <stdio.h>  
2. #include <stdlib.h>  
3.   
4. int main(int argc, char *argv[])   
5. {  
6. /*  int a[20]={1,2,4}; 
7.     printf("%d\n",sizeof(a)); 
8.     printf("%p\n",a); 
9.     printf("%p\n",&a); 
10.     printf("%p\n",&a[0]);    
11. */  
12.   
13.   
14. /*  int a[5]={1,2,3,4,5}; 
15.     int (*p)[5]=&a; 
16.     printf("%d\n",*((int *)(p+1)-1)); 
17. */    
18.       
19.     int a[5]={1,2,3,4,5};  
20.     int* p=(int *)(&a+1);  
21. //  int *p=&a+1;  //这个条语句是  把&a这个数组指针 进行了指针运算后  的那个地址  强制类型转换成了 int *指针   
22.     printf("%d\n",*(p-1));  
23.     return 0;  
24.       
25. }  

5.访问指针和访问数组的两种方式：

    分别是以下标方式访问和以指针的方式访问，我觉得没有任何区别，*(p+4)和p[4]是一样的 ，其实都可以理解成指针运算。如果非要说出区别，我觉得指针的方式会快些，但是在当前的硬件和编译器角度看，不会太明显。同样下标的方式可读性可能会高些。

6.切记数组不是指针：
    数组是数组，指针是指针，根本就是两个完全不一样的东西。当然要是在宏观的内存角度看，那一段相同类型的连续空间，可以说的上是数组。但是你可以尝试下，定义一个指针，在其他地方把他声明成数组，看看编译器会不会把两者混为一谈，反过来也不会。

    但是为什么我们会经常弄混呢？第一，我们常常利用指针的方式去访问数组。第二，数组作为函数参数的时候，编译器会把它退化成为指针，因为函数的参数是拷贝，如果是一个很大的数组，拷贝是很浪费内存的，所以数组会被退化成指针(这里一定要理解好，退化的是数组成员的类型指针，不一定是数组指针的哈)。

7.弄清数组的类型：

   数组类型是由数组元素类型和数组长度两个因素决定的，这一点在数组中体现的不明显，在数组指针的使用中体现的很好。

[cpp] view plaincopy

1. char a[5]={'a','b','c','d','e'};  
2. char (*p)[3]=&a;  

   上面的代码是错误的，为什么？因为数组指针和数组不是一个类型，数组指针是指向一个数组元素为char 长度为3的类型的数组的，而这个数组的类型是数组元素是char长度是5，类型不匹配，所以是错的。

8.字符串问题：

   a.C语言中没有真正的字符串，是用字符数组模拟的，即：字符串就是以'\0'结束的字符数组。

   b.要注意下strlen，strcmp等这个几个函数的返回值，是有符号的还是无符号的，这里很容易忽略返回值类型，造成操作错误。

   c.使用一条语句实现strlen，代码如下(此处注意assert函数的使用，安全性检测很重要)：

[cpp] view plaincopy

1. #include <stdio.h>  
2. #include <assert.h>  
3.   
4. int strlen(const char* s)  
5. {  
6.     return ( assert(s), (*s ? (strlen(s+1) + 1) : 0) );  
7. }  
8.   
9. int main()  
10. {  
11.     printf("%d\n", strlen( NULL));  
12.       
13.     return 0;  
14. }  

    d.自己动手实现strcpy，代码如下：

[cpp] view plaincopy

1. #include <stdio.h>  
2. #include <assert.h>  
3.   
4. char* strcpy(char* dst, const char* src)  
5. {  
6.     char* ret = dst;  
7.       
8.     assert(dst && src);  
9.       
10.     while( (*dst++ = *src++) != '\0' );  
11.       
12.     return ret;  
13. }  
14.   
15. int main()  
16. {  
17.     char dst[20];  
18.   
19.     printf("%s\n", strcpy(dst, "hello!"));  
20.       
21.     return 0;  
22. }  

     e.推荐使用strncpy、strncat、strncmp这类长度受限的函数(这些函数还能在字符串后面自动补充'\0')，不太推荐使用strcpy、strcmpy、strcat等长度不受限仅仅依赖于'\0'进行操作的一系列函数，安全性较低。
     f.补充问题，为什么对于字符串char a[256] = "hello";，在printf和scanf函数中，使用a行，使用&a也行？代码如下：

[cpp] view plaincopy

1. #include <stdio.h>  
2. int main()  
3. {  
4.     char* p ="phello";  
5.     char a[256] = "aworld";  
6.     char b[25] = {'b','b','c','d'};  
7.     char (*q)[256]=&a;  
8.       
9.     printf("%p\n",a);  //0022fe48  
10.     //printf("%p\n",&a);  
11.     //printf("%p\n",&a[0]);  
12.       
13.       
14.     printf("tian %s\n",(0x22fe48));   
15.     printf("%s\n",q);    //q就是&a   
16.     printf("%s\n",*q);   //q就是a   
17.       
18.     printf("%s\n",p);  
19.       
20.     printf("%s\n",a);  
21.     printf("%s\n",&a);  
22.     printf("%s\n",&a[0]);  
23.       
24.     printf("%s\n",b);  
25.     printf("%s\n",&b);  
26.     printf("%s\n",&b[0]);     
27. }  

对于上面的代码：中的0x22fe48是根据打印a的值获得的。

printf("tian %s\n",(0x22fe48));这条语句，可以看出来printf真的是不区分类型啊，完全是根据%s来判断类型。后面只需要一个值，就是字符串的首地址。a、&a、&a[0]三者的值还恰巧相等，所以说三个都行，因为printf根本就不判断指针类型。虽然都行但是我觉得要写有意义的代码，所以最好使用a和*p。还有一个问题就是，char* p = "hello"这是一个char*指针指向hello字符串。所以对于这种方式只能使用p。因为*p是hello字符串的第一个元素，即：‘h’，&p是char* 指针的地址，只有p是保存的hello字符串的首地址，所以只有p可以，其他都不可以。scanf同理，因为&a和a的值相同，且都是数组地址。

9.二维数组(本节最重要的知识点)：

      a.对于二维数组来说，二维数组就是一个一维数组 数组，每一个数组成员还是一个数组，比如int a[3][3]，可以看做3个一维数组，数组名分别是a[0]  a[1]   a[2]   sizeof(a[0])就是一维数组的大小  ，*a[0]是一维数组首元素的值，&a[0]是 一维数组的数组指针。

      b.也可以通过另一个角度看这个问题。a是二维数组的数组名，数组元素分别是数组名为a[0]、a[1]、a[2]的三个一维数组。对a[0]这个数组来说，它的数组元素分别是a[0][0]  a[0][1]  、 a[0][2]三个元素。a和a[0]都是数组名，但是是两个级别的，a作为数组首元素地址的时候等价于&a[0](最容易出问题的地方在这里，这里一定要弄清此时的a[0]是什么，此时的a[0]是数组名，不是数组首元素的地址，不可以继续等价下去了，千万不能这样想 a是&a[0]    a[0]是&a[0][0]     a就是&&a[0][0] 然后再弄个2级指针出来，自己就蒙了！！！这是一个典型的错误，首先&&a[0][0]就没有任何意义，跟2级指针一点关系都没有，然后a[0]此时不代表数组首元素地址，所以这个等价是不成立的。Ps：一定要搞清概念，很重要！！！ )，a[0]作为数组首元素地址的时候等价于&a[0][0]。但是二维数组的数组头有很多讲究，就是a(二维数组名)、&a(二维数组的数组地址)、&a[0](二维数组首元素地址  即a[0]一维数组的数组地址 a有的时候也表示这个意思)、a[0](二维数组的第一个元素 即a[0]一维数组的数组名)、&a[0][0](a[0]一维数组的数组首元素的地址 a[0]有的时候也表示这个意思)，这些值都是相等，但是他们类型不相同，行为也就不相同，意义也不相同。分析他们一定要先搞清，他们分别代表什么。

下面是一个，二维数组中指针运算的练习(指针运算的规则不变，类型决定行为)：

[cpp] view plaincopy

1. #include <stdio.h>  
2. #include <stdlib.h>  
3. #include <stdbool.h>  
4.   
5. int main(int argc, char *argv[])   
6. {  
7.     int a[3][3]={1,2,3,4,5,6,7,8,9};  
8.     printf("%d\n",sizeof(a[0]));  
9.     printf("%d\n",*a[2]);  
10.     printf("%d\n",*(a[0]+1));  
11.       
12.     printf("%p\n",a[0]);  
13.     printf("%p\n",a[1]);  
14.     printf("%p\n",&a[0]+1); //&a[0]+1 跟 a[1]不一样  指针类型不一样   &a[0]+1这个是数组指针  a[1]是&a[1][0] 是int*指针   
15.       
16.     printf("%d\n",*((int *)(&a[0]+1)));  
17.       
18.     printf("%d\n",*(a[1]+1));  
19.       
20.     printf("%p\n",a);  
21.     printf("%p\n",&a);  
22.     printf("%p\n",&a[0]);  
23.       
24.     printf("%d\n",sizeof(a));   //这是a当作数组名的时候  
25.       
26.     printf("%d\n",*((int *)(a+1))); //此时 a是数组首元素的地址  数组首元素是a[0]    
27.                  //首元素地址是&a[0]  恰巧a[0]是数组名 &a[0]就变成了数组指针   
28.     return 0;  
29. }  

总结：对于a和a[0]、a[1]等这些即当作数组名，又当作数组首元素地址，有时候还当作数组元素(即使当作数组元素，也无非就是当数组名，当数组首元素地址两种)，这种特殊的变量，一定要先搞清它现在是当作什么用的。

      c.二维数组中一定要注意，大括号，还是小括号，意义不一样的。

10.二维数组和二级指针：

     很多人看到二维数组，都回想到二级指针，首先我要说二级指针跟二维数组毫无关系，真的是一点关系都没有。通过指针类型的分析，就可以看出来两者毫无关系。不要在这个问题上纠结。二级指针只跟指针数组有关系，如果这个二维数组是一个二维的指针数组，那自然就跟二级指针有关系了，其他类型的数组则毫无关系。切记！！！还有就是二级指针与数组指针也毫无关系！！

11.二维数组的访问：

     二维数组有以下的几种访问方式：

     int   a[3][3];对于一个这样的二位数组

     a.方式一：printf("%d\n",a[2][2]); 

     b.方式二：printf("%d\n",*(a[1]+1));

     c.方式三：printf("%d\n",*(*(a+1)+1));

     d.方式四：其实二维数组在内存中也是连续的，这么看也是一个一维数组，所以就可以使用这个方式，利用数组成员类型的指针。

[cpp] view plaincopy

1. int *q;  
2. q = (int *)a;  
3. printf("%d\n",*(q+6));  

     e.方式五：二维数组中是由多个一维数组组成的，所以就可以利用数组指针来访问二维数组。

[cpp] view plaincopy

1. int (*p)[3];  
2. p = a;  
3. printf("%d\n",*(*(p+1)+1));  

给一个整体的程序代码：

[cpp] view plaincopy

1. #include <stdio.h>  
2. #include <stdlib.h>  
3. #include <string.h>  
4. int main()  
5. {  
6.     int a[3][3]={1,2,3,4,5,6,7,8,9};  
7.     int (*p)[3];  
8.     int *q;   
9.     printf("%d\n",*(*(a+1)+1));   //a        *(&a[0]+1)  
10.     p = a;  
11.     q = (int *)a;  
12.     printf("%d\n",*(*(p+1)+1));  
13.     printf("%d\n",*(a[1]+1));  
14.     printf("%d\n",a[1][1]);  
15.     printf("%d\n",*(q+6));  
16. }  
17. <span style="font-family:Arial;BACKGROUND-COLOR: #ffffff"></span>  

 

总结：对于二位数组int a[3][3]  要想定义一个指针指向这个二维数组的数组元素(即a[0]等一维数组)，就要使用数组指针，这个数组指针要跟数组类型相同。a[0]等数组类型是元素类型是int，长度是3，所以数组指针就要定义成int (*p)[3]。后面的这个维度一定要匹配上，不然的话类型是不相同的。

这里有一个程序，要记得在c编译器中编译，这个程序能看出类型相同的重要性：

[cpp] view plaincopy

1. <span style="color:#000000;">#include <stdio.h>  
2.   
3. int main()  
4. {  
5.     int a[5][5];  
6.     int(*p)[4];  
7.       
8.     p = a;  
9.       
10.     printf("%d\n", &p[4][2] - &a[4][2]);  
11. }</span>  

12.二级指针：

    a.因为指针同样存在传值调用和传址调用，并且还有指针数组这个东西的存在，所以二级指针还是有它的存在价值的。

    b.常使用二级指针的地方：

          (1)函数中想要改变指针指向的情况，其实也就是函数中指针的传址调用，如：重置动态空间大小，代码如下：

[cpp] view plaincopy

1. #include <stdio.h>  
2. #include <malloc.h>  
3.   
4. int reset(char**p, int size, int new_size)  
5. {  
6.     int ret = 1;  
7.     int i = 0;  
8.     int len = 0;  
9.     char* pt = NULL;  
10.     char* tmp = NULL;  
11.     char* pp = *p;  
12.       
13.     if( (p != NULL) && (new_size > 0) )  
14.     {  
15.         pt = (char*)malloc(new_size);  
16.           
17.         tmp = pt;  
18.           
19.         len = (size < new_size) ? size : new_size;  
20.           
21.         for(i=0; i<len; i++)  
22.         {  
23.             *tmp++ = *pp++;        
24.         }  
25.           
26.         free(*p);  
27.         *p = pt;  
28.     }  
29.     else  
30.     {  
31.         ret = 0;  
32.     }  
33.       
34.     return ret;  
35. }  
36.   
37. int main()  
38. {  
39.     char* p = (char*)malloc(5);  
40.       
41.     printf("%0X\n", p);  
42.       
43.     if( reset(&p, 5, 3) )  
44.     {  
45.         printf("%0X\n", p);  
46.     }  
47.       
48.     return 0;  
49. }  

             (2)函数中传递指针数组的时候，实参(指针数组)要退化成形参(二级指针)。

             (3)定义一个指针指向指针数组的元素的时候，要使用二级指针。

      c.指针数组：char* p[4]={"afje","bab","ewrw"};  这是一个指针数组，数组中有4个char*型的指针，分别保存的是"afje"、"bab"、"ewrw"3个字符串的地址。p是数组首元素的地址即保存"afje"字符串char*指针的地址。

[cpp] view plaincopy

1. #include <stdio.h>  
2. #include <stdlib.h>  
3. #include <stdbool.h>  
4.   
5. int main(int argc, char *argv[])   
6. {     
7.     char* p[4]={"afje","bab","ewrw"};  
8.     char* *d=p;   
9.     printf("%s\n",*(p+1));    
10.     printf("%s\n",*(d+1));  //d  &p[0] p[0]是"afje"的地址，所以&p[0]是保存"afje"字符串的char*指针的地址      
11.     return 0;  
12. }  

       d.子函数malloc，主函数free，这是可以的(有两种办法，第一种是利用return 把malloc的地址返回。第二种是利用二级指针，传递一个指针的地址，然后把malloc的地址保存出来)。记住不管函数参数是，指针还是数组， 当改变了指针的指向的时候，就会出问题，因为子函数中的指针就跟主函数的指针不一样了，他只是一个复制品，但可以改变指针指向的内容。这个知识点可以看<在某培训机构的听课笔记>这篇文章。

13.数组作为函数参数：数组作为函数的实参的时候，往往会退化成数组元素类型的指针。如：int a[5]，会退化成int*   ；指针数组会退化成二级指针；二维数组会退化成一维数组指针；三维数组会退化成二维数组指针(三维数组的这个是我猜得，如果说错了，希望大家帮我指出来，谢谢)。如图：

二维数组作为实参的例子：

[cpp] view plaincopy

1. #include <stdio.h>  
2. #include <stdlib.h>  
3. #include <stdbool.h>  
4.   
5. int fun(int (*b)[3])  //此时的b为  &a[0]   
6. {  
7.     printf("%d\n",*(*(b+1)+0));  
8.     printf("%d\n",b[2][2]);// b[2][2] 就是  (*(*(b+2)+2))  
9.     printf("%d\n",*(b[1]+2));  
10. }  
11.   
12. int main(int argc, char *argv[])   
13. {  
14.     int a[3][3]={1,2,3,4,5,6,7,8,9};  
15.      fun(a);//与下句话等价  
16.      fun(&a[0]);      
17.     return 0;  
18. }  

       数组当作实参的时候，会退化成指针。指针当做实参的时候，就是单纯的拷贝了！

14.函数指针与指针函数：
      a.对于函数名来说，它是函数的入口，其实函数的入口就是一个地址，这个函数名也就是这个地址。这一点用汇编语言的思想很容易理解。下面一段代码说明函数名其实就是一个地址，代码如下：

[cpp] view plaincopy

1. #include <stdio.h>  
2. #include <stdlib.h>  
3. #include <stdbool.h>  
4.   
5. void abc()  
6. {  
7.     printf("hello fun\n");  
8. }  
9. int main(int argc, char *argv[])   
10. {  
11.     void (*d)();  
12.     void (*p)();  
13.     p = abc;  
14.     abc();  
15.     printf("%p\n",abc);  
16.     printf("%p\n",&abc);//函数abc的地址0x40138c  
17.     p();  
18.     (*p)();       
19.     d = ((unsigned int*)0x40138c);  //其实就算d= 0x40138c这么给赋值也没问题   
20.     d();  
21.     return 0;  
22. }     
23.    

可见函数名就是一个地址，所以函数名abc与&abc没有区别，所以p和*p也没有区别。

    b.我觉得函数指针最重要的是它的应用环境，如回调函数(其实就是利用函数指针，把函数当作参数进行传递)代码如下，还有中断处理函数(同理)详细见<

ok6410学习笔记(16.按键中断控制led)>中的 中断注册函数，request_irq。还有就是函数指针数组，第一次见到函数指针数组是在zigbee协议栈中。

回调函数原理代码：

[cpp] view plaincopy

1. #include <stdio.h>  
2.   
3. typedef int(*FUNCTION)(int);  
4.   
5. int g(int n, FUNCTION f)  
6. {  
7.     int i = 0;  
8.     int ret = 0;  
9.       
10.     for(i=1; i<=n; i++)  
11.     {  
12.         ret += i*f(i);  
13.     }  
14.       
15.     return ret;  
16. }  
17.   
18. int f1(int x)  
19. {  
20.     return x + 1;  
21. }  
22.   
23. int f2(int x)  
24. {  
25.     return 2*x - 1;  
26. }  
27.   
28. int f3(int x)  
29. {  
30.     return -x;  
31. }  
32.   
33. int main()  
34. {  
35.     printf("x * f1(x): %d\n", g(3, f1));  
36.     printf("x * f2(x): %d\n", g(3, &f2));  
37.     printf("x * f3(x): %d\n", g(3, f3));  
38. }  

注意：可以使用函数名f2，函数名取地址&f2都可以，但是不能有括号。

       c.所谓指针函数其实真的没什么好说的，就是一个返回值为指针的函数而已。

15.赋值指针的阅读：

       a.char* (*p[3])(char* d); 这是定义一个函数指针数组，一个数组，数组元素都是指针，这个指针是指向函数的，什么样的函数参数为char*  返回值为char*的函数。

分析过程：char (*p)[3] 这是一个数组指针、char* p[3] 这是一个指针数组  char* 是数组元素类型、char* p(char* d) 这个是一个函数返回值类型是char* 、char (*p)(char* d)这个是一个 函数指针。可见char* (*p[3])(char* d)是一个数组  数组中元素类型是 指向函数的指针，char* (* )(char* d) 这是函数指针类型，char* (* )(char* d) p[3] 函数指针数组 这个不好看 就放里面了。(PS：这个看看就好了~~~当娱乐吧)

      b.函数指针数组的指针：char* (*(*pf)[3])(char* p) //这个就看看吧  我觉得意义也不大 因为这个逻辑要是一直下去 就递归循环了。

分析过程：char* (* )(char *p) 函数指针类型，char* (*)(char *p) (*p)[3]  函数指针 数组指针  也不好看 就放里面了。