C语言学习之路之六--------指针初学

指针：
    指针是一个 4 bytes Integers，保存的是内存地址，
    
1.定义：  
     类型 * 变量名：

     int * p;这样定义的话，p是有地址也有值，不过值是随机值
    应该为其初始化： int * p = null；
    不提倡不同类型的一起运用：
           char c = 'e';
           int *p = &c;
  也不提倡直接让其等于一个地址：
           int *p = 0xffff22;

2.使用const声明指针变量
    1).指向const的指针变量
       int const *p; 等效于 const int *p;
       该类指针变量指向的内存空间的内容是不可变的。
       eg.  const int a = 1;
            const int * p = &a;
          a的值是不可以改变的
    2).const型指针变量
       int * const p；
        指向的内存空间是固定的，初始化后不能将其指向其他空间，就是说p 不可以再等于其它的地址。
    3).指向const的const指针变量
        const int * const p;
        该指针变量的值和该指针指向的空间的值都是不可以改变的。
       
3.

[csharp]  view plain copy

1. int a;  
2.     int *p;  
3.     p = &a;  

 

这样是正确的，a的值是无效值，但是系统给它分配了内存空间了，地址是有效的。只有系统回收的和自己定义的是无效的。

4.指针形参
  可以将一个内存空间的地址传递到函数中，通过该地址来操作改地址上的内存空间
声明方式：void func(int *p,int *q);

eg:
把a和b值进行交换：

通常的方法：进行传值操作，这样是不能实现交换

[csharp]  view plain copy

1. #include <stdio.h>  
2. #include<math.h>  
3. void swap(int,int);  
4.   
5. int main(){  
6.    int a = 1;  
7.    int b = 2;  
8.     swap(a,b);  
9.     printf("a=%d b=%d\n",a,b);  
10.     return 0;  
11. }  
12.   
13. void swap(int a,int b){  
14.     int temp = 0;  
15.     temp = a;  
16.     a = b;  
17.     b = temp;  
18.     printf("a= %d b=%d\n",a,b);  
19. }  

正确的方法：进行传地址（指针）的操作，从而实现替换

[csharp]  view plain copy

1. #include <stdio.h>  
2. #include<math.h>  
3.   
4. void exchange(int *,int *);//声明  
5.   
6. int main(){  
7. //定义两个int型数  
8.     int a = 5;  
9.     int b = 7;  
10.     printf("a=%d b=%d\n",a,b);//输出a和b的值  
11.     exchange(&a,&b);//调用  
12.     return 0;  
13. }  
14. void exchange(int *x,int *y){  
15.     int temp;//定义中间变量  
16.     temp = *x;  
17.     *x = *y;  
18.     *y = temp;  
19.     printf("a=%d b=%d\n",*x,*y);//输出  
20. }  

5.指针型函数值
  函数的函数返回值也可以是指针型的数据，即地址。
　数据类型　*　函数名（形参列表）;
eg:

[csharp]  view plain copy

1. #include <stdio.h>  
2. int * max(int * ,int *);//声明  
3. int main(){  
4.     int a = 1;  
5.     int b = 2;  
6.     int *p = NULL;//定义一个int型的指针来接收函数  
7.   
8. add的返回值  
9.     p = max(&a,&b);//把地址传过去  
10.     printf("%d\n",*p);//输出  
11.       
12.     return 0;  
13. }  
14. int * max(int * a,int *b){  
15.     int *p = NULL;//初始化  
16.     if(*a>*b){  
17.         p =a;  
18.     }else{  
19.         p = b;  
20.     }  
21.     return p;  
22. }  

注意：
错乱时空：

[csharp]  view plain copy

1. float *mistake(){  
2.     float temp = 12;  
3.     float *p = &temp;  
4.     return p;  
5. }  

 

temp 只有在mistake这个方法块里面有效，当存在返回语句的时候，意味着在外界可能会使用也可能不会使用，所以会出现：有时候会出错误，有时候不会出错。。错乱

6.函数型指针
    指向函数的指针，可以表示出函数的地址
    有这样一个函数声明：
    int add(const int a,const int b);
    使用该函数类型来定义一个函数型指针：
    int (*fq)(const int a ,const int b);
  就是相当于把存有函数的地址的函数变量func赋给了fq这个

指针：fq = add；
   注意：(*fq)  这个小括号千万不能省略
   调用的两种方法：fq(3,3); 或  (*fq)(3,3)
  eg:

[csharp]  view plain copy

1. #include<stdio.h>  
2. int add(const int a,const int b){  
3.     return a + b;  
4. }  
5. int main(){  
6.     //定义函数指针  
7.     int (*fp)(const int a,const int b);   
8.     //赋值  
9.     fp = add;  
10.     //调用，输出  
11.     printf("%d\n",fp(3,4));  
12.     printf("%d\n",(*fp)(3,4));  
13.   
14.     //输出函数的地址  
15.     printf("%p\n",add);  
16.     printf("%p\n",&add);  
17.     printf("%p\n",fp);  
18.     printf("%p\n",*fp);  
19.     return 0;  
20. }  

7.void型指针
  可以指向存储任意数据类型的空间，也就是它包含了所有的

类型，常作为形参出现，它可以指向任意类型的指针变量；也

可以作为函数的函数值。
  定义形式：void * 变量名；
     

8.
指针的调用：（一二三级指针的使用）

[csharp]  view plain copy

1. #include <stdio.h>  
2. #include<math.h>  
3. int main(){  
4.     int a =1;  
5.     int *b;  
6.     b = &a;  
7.     printf("b的值(a的地址)：%p\n",b);  
8.     printf("a的值：%d\n",*b);  
9.     printf("b的地址：%p\n",&b);  
10.     printf("---------------------------\n");  
11.     int **q;  
12.     q = &b;  
13.     printf("q的值(b的地址)：%p\n",q);  
14.     printf("b的值(a的地址): %p\n",*q);  
15.     printf("a的值：%d\n",**q);  
16.     printf("q的地址：%p\n",&q);  
17.     printf("---------------------------\n");  
18.     int ***r;  
19.     r = &q;  
20.     printf("r的值(q的地址):%p\n",r);  
21.     printf("q的值(b的地址)：%p\n",*r);  
22.     printf("b的值(a的地址)：%p\n",**r);  
23.     printf("a的值：%d\n",***r);  
24.     printf("r的地址: %p\n",&r);  
25.     return 0;  
26. }