C总结之指针

C总结之指针总结

1.指针

1.1函数指针

   函数指针简单说就是一个指针指向了函数的执行地址，这样定义一个函数指针，就可以动态的指向相同参数及返回值的一类函数，比如add，sub，mul，div。

函数指针的定义如下

int (*p)(int a,int b);//p指针表示指向一个带2个int参数并且返回值是int的一类函数


eg：

    #include <stdio.h>

    //加法
    int Add(int a,int b){
        return a + b;
    }

    //减法
    int Sub(int a,int b){
        return a - b;
    }

    //乘法
    int Mul(int a,int b){
        return a * b;
    }

    //除法
    int Div(int a,int b){
        return a/b;
    }

    int main(int argc, const char * argv[]) {
        // insert code here...

        //定义一个函数指针
        int (*p)(int a,int b);

        p = &Add;
        printf("5 add 3 is %d\n",(*p)(5,3));//使用函数指针

        p = &Sub;
        printf("5 sub 3 is %d\n",(*p)(5,3));//使用函数指针
        return 0;
    }

结果是：

5 add 3 is 8
5 sub 3 is 2
Program ended with exit code: 0

*p必须使用括号括起来
int (*p)(int a,int b),此时p表示函数指针，指针指向某个函数
int p(int a,int b),此时表示声明p函数，p函数有两个参数，都是int，返回值是一个int的指针。所以要注意。

1.2指针函数

指针函数和函数指针有什么不同点。函数指针是指针指向一个函数，而指针函数表示函数的返回值是一个指针。

使用如下：

    int *p(int a,int b);//指针函数，表示声明了一个p函数，函数的返回值是一个int的指针

e.g:

    #include <stdio.h>
    #include <stdlib.h>

    //int *p(int a,int b);

    int *p(int a,int b){
        int* result;
        result = malloc(sizeof(int));
        (*result) = a + b;
        return result;
    }

    int main(int argc, const char * argv[]) {
        // insert code here...

        //使用指针函数
        int *result;
        result = p(5,8);
        printf("result is %d\n",(*result));
        //释放指针空间
        return 0;
    }

结果是:

result is 13
Program ended with exit code: 0

1.3双重指针

双重指针就好比要指向两次才到达目标源。比如，开一个房间（目标源）需要一把钥匙A，但是钥匙A放在了前台的柜子里，开柜子就需要钥匙B，因此要先拿到钥匙B开了柜子再拿钥匙A才可以开房间的门。

    int **p;//定义双重指针

eg：

    #include <stdio.h>
    #include <stdlib.h>

    int main(int argc, const char * argv[]) {
        // insert code here...

        int source = 100;

        int *B = &source;

        int **A = &B;

        printf("A指针的地址是  %p\n",A);

        printf("*A指针指向的内容就是B指针的地址  %p\n",*A);

        printf("直接打印B指针的地址   %p\n",B);  //明显发现，B 和 *A结果是一样的

        printf("**A指针其实就是先*A找到了中间指针的地址（也就是B指针的地址），再*(*A)也就是*B指向最终的数据源是  %d\n",**A);

        return 0;
    }

结果是:

A指针的地址是  0x7fff5fbff700
*A指针指向的内容就是B指针的地址  0x7fff5fbff70c
直接打印B指针的地址   0x7fff5fbff70c
**A指针其实就是先*A找到了中间指针的地址（也就是B指针的地址），再*(*A)也就是*B指向最终的数据源是  100
Program ended with exit code: 0

1.4常指针与指向常引用的指针

1.4.1常指针

常指针，通过名称就知道表示指针只能指向一个地址，不可以修改指针指向的地址，也就是不同给指针重新复制

     int* const p ;//可以看到，const的位置是在p指针前面，也就是说他只修饰p，p是常量，p代表的是指针的指向，所以很明显p不可以指向其他的地址

eg：

    #include <stdio.h>
    #include <stdlib.h>

    int main(int argc, const char * argv[]) {
        // insert code here...

        int source = 100;

        int other = 200;

        int* const p = &source;

        printf("p 指向的值是 %d\n",(*p));

        //p = &other;   编译错误，因为无法改变p指向的地址

        //printf("修改p指向后，的值是 %d\n",(*p));

        return 0;
    }

结果是:

p 指向的值是 100
Program ended with exit code: 0

1.4.2指向常引用的指针

指向常引用的指针，也就是说，指针指向的内容不可以修改，重点！重点！重点！只是不能通过指针来修改，但是可以通过原来的引用来修改，换句话来说*p不能在=的左边，不能重新给指向的内容修改

定义如下:

    const int *p;//可以看出const修饰的是整个*p，那*p表示的是指针指向的内容，因此也就是指向的内容无法修改

eg：

    #include <stdio.h>
    #include <stdlib.h>

    int main(int argc, const char * argv[]) {
        // insert code here...

        int source = 100;

        const int* p = &source;

        printf("p 刚开始指向的source值是 %d\n",(*p));

        //(*p) = 200;   //错误，因为不能通过指向常引用的指针进行修改值

        //printf("通过指向常引用的指针就行修改值是 %d\n",(*p));

        source = 200;

        printf("通过source修改值后，使用*p打印的结果是 %d\n",(*p));

        return 0;
    }

结果是:

p 刚开始指向的source值是 100
通过source修改值后，使用*p打印的结果是 200
Program ended with exit code: 0