对于C指针的一些感悟

声明：仅是个人的一些理解，如有错误，请友好交流讨论

1、变量名是什么

	int a = 10;
	int *pa = &a;

这里举了两个例子，分别是一个 int 类型的 a，int* 类型的 pa，我的理解是一个变量名是一个盒子，里面存放着一些东西，里面的东西就是指定的类型的。pa 里面存放的是 int 类型的一个指针，也就是里面放的是一个地址，指向着一块放着 int 数据的地方。而 a 里面存放的是 int 类型的一个数据，对于我们来说，使用这种更加地方便。如果是 pa 指针,我们需要 *pa 才能取出我们需要的数据。

2、变量之间的赋值

首先，变量之间的赋值是将盒子里面装的东西赋值给别人。对于 int 类型这种，赋值就是将里面的数据赋给别人。如果是 pa ，那么就是将里面存放的地址赋值给别人。也就是都可以通过这个地址找到同一份数据。

3、指针的便利性和不便性

对于 int 类型，看下面的例子：

#include<stdio.h>
int main(){
	int a = 10;
    int b = a;
    printf("a = %d, b = %d\n", a, b);
    a = 20;
    printf("a = %d, b = %d\n", a, b);
	return 0;
}

result:
a = 10, b = 10
a = 20, b = 10

第一次赋值，b 得到了 a 里面的值，这时 a 和 b 都拥有了相同的数据10，第二次我们改变原来的 a 值，发现 b 并没有受到影响，还是原来的10， 说明第一次的赋值时只是拷贝了盒子里面存放的数据。

对于指针类型，看下面的例子：

#include<stdio.h>
int main(){
    int a = 10;
    int *pb = &a;
    printf("a = %d, *pb = %d\n", a, *pb);
    *pb = 20;
    printf("a = %d, *pb = %d\n", a, *pb);
	return 0;
}

result:
a = 10, *pb = 10
a = 20, *pb = 20

第一次赋值是将 a 的地址赋值给 pb ,也就是 pb 里面接受到的其实只是 a 的地址，但是 pb 可以通过这个地址访问到 a 里面保存的数据。pb 也可以修改指向的内存空间的数据，也就是第二次赋值 *pb=20，但是 pb 里面存放的地址是没有变的，对于我们来说，我们只关心最终保存的10这个数据，而不太关心里面存放的地址到底是什么，到现在我们保存数据有了两种途径，一种是直接保存，另外一种是保存一块地址，在指向的内存空间里面保存数据。如果要想多个人操作同一份数据，选第一种保存数据的方式是不够的，这时我们就必须使用指针来保存它的地址，通过这个每个人保存的地址找到同一块地方，进而修改大家都能访问到的数据，达到多人操作同一份数据的目的。但是这种多人可以操作同一份数据有的时候并不是一件好事，例如在某处意外修改，导致大家看到的数据都会发生变化！

4、再谈链表

这里奉上个人觉得最简单的链表创建形式，使用了指针的多人操作同一份数据的特性，看下面的代码：

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

typedef struct Node{
    int data;
    struct Node *next;
}Node;

Node *head = NULL;
Node *tail = NULL;

void init(){
    head = (Node*)malloc(sizeof(Node));
    tail = head;
    tail->next = NULL;
}

//向链表中添加数据
void add(){
    //输入-1表示结束添加节点
    int data;
    //每次需要添加上去的节点
    Node *tmp = NULL;
    while(1){
        scanf("%d", &data);
        if(-1 == data)
            break;
        tmp = (Node*)malloc(sizeof(Node));
        tmp->data = data;
        //添加到链表
        tail->next = tmp;
        tail = tmp;
        tail->next = NULL;
    }
    printf("----输入结束----\n");
}

//遍历输出链表
void traverse(){
    Node *tmp = head->next;
    while(tmp){
        printf("%d ", tmp->data);
        tmp = tmp->next;
    }
}

int main() {
    init();
    add();
    traverse();
    return 0;
}

result:
10
20
30
-1
----输入结束----
10 20 30

这里为了简单起见，对于一个链表我保存了头节点 head 和尾节点 tail，并且定义成全局变量，这样不需要在函数之间传递参数， 头节点不保存数据，只做一个标识作用，用于找到整个链表。先看 init() 函数，它的目的是对指针进行初始化，指针在使用之前都需要指定一块具体的内存空间。刚开始，头节点和尾节点应该是完全一样的，所以完成 head 指针的初始化后，只需要 tail=head，这样 head 和 tail 保存的就是同一个地址，进而可以操作同一份数据，接下来的 tail->next=NULL 也会影响 head 指向的内存空间的值，也就是 head->next 也会被赋值为 NULL ，所以初始化过程只需要这三步，不需要其他的操作了。再看 add() 函数，这是往链表中添加节点的函数，每次要有一个新的节点生成，保存数据，然后链接到链表上。先看 tmp 这个盒子，每次输入一个 data 之后，表名需要一个新的节点，这时通过 tmp=(Node)malloc(sizeof(Node))* 之后，tmp 盒子里面存放的地址已经变了，所以这个盒子每次都是新的。而链表当中，我们也只是通过指针找到内存空间，进而访问里面的数据。看最关键的链接操作，
tail->next=tmp;
tail=tmp;
tail->next=NULL;
，因为 tail 是整个链表的尾部，所以每次只需要插在 tail 的后面，也就是 tail->next=tmp; 但是为了保持 tail 始终是最后一个，所以还需要 tail=tmp ，再加上 tail->next=NULL; 整个操作就结束了。对于链表来讲，始终都是通过指针来找到下一个，所以这是指针的典型应用。

5、参数传递问题

先看一个简单的例子：

#include <stdio.h>

void fn(int a){
    a = 202;
    printf("fn函数中的a = %d\n", a);
}

int main() {
    int a = 101;
    printf("main函数将a作为参数之前的值: %d\n", a);
    fn(a);
    printf("main函数中的a = %d\n", a);
    return 0;
}

result:
main函数将a作为参数之前的值: 101
fn函数中的a = 202
main函数中的a = 101

这里的参数传递其实是in-mode，也就是参数在函数中被改变，并不能带出去，在外面还是没有被改变（直观的感受）。但其实并没有这么简单，参数传递只是复制一份参数，然后再函数中使用，也就是使用了新的盒子，只是里面的东西装的是一样的，既然直接传一个 int 参数，那么两个盒子，两份内容，但是不是同一份内容，可以理解为两个盒子里面的值所占据的内存空间并不一样。
再看一个例子：

#include <stdio.h>

void fn(int *pa){
    *pa = 202;
    printf("fn函数中的a = %d\n", *pa);
}

int main() {
    int a = 101;
    printf("main函数将a作为参数之前的值: %d\n", a);
    fn(&a);
    printf("main函数种的a = %d\n", a);
    return 0;
}

result:
main函数将a作为参数之前的值: 101
fn函数中的a = 202
main函数种的a = 202

这里，a 的值被改变了？分析fn() 函数的参数，会发现已经换成了 int* 也就是传进去的是一个指针了，按照前面的理论， 调用 fn() 函数时，新建一个盒子，里面存放相同的数据，也就是一个地址，和 a 相同的地址，在fn() 函数中，我通过 pa=202 ，也就是通过 pa 这个指针，找到了和a的那块内存空间，并且修改了里面的值，也就是前面讲到的多人操作同一份数据，使用地址达到了这个目的。这里并没有违背参数传递只是复制一个数据的理论，只是通过这个值（指针）修改了大家都能看到的数据。

6、参数传递的延申

我现在的一个需求，在main函数有一个指针，我希望通过函数调用，改变其中保存的内容，也就是里面的地址。看实现：

#include <stdio.h>
#include <stdlib.h>
void fn(int **pa){
    *pa = (int*)malloc(sizeof(int));
}

int main() {
    int *pa = (int*)malloc(sizeof(int));
    printf("传入fn函数之前pa的地址：%p\n", pa);
    fn(&pa);
    printf("传入fn函数之后pa的地址：%p\n", pa);
    return 0;
}

result:
传入fn函数之前pa的地址：0000000000791440
传入fn函数之后pa的地址：0000000000791460

总结：经过一个函数之后，如果希望改变能带出去，影响外面的值，就应该传一个它的指针，在函数内通过这个指针去找到要修改的内存空间，进而修改值。