深入理解C指针

深入理解C指针

---

什么是变量

变量就是一块可以存放数据的内存空间，这块内存空间的大小，取决于变量的类型。

什么是指针

内存在计算机中以字节为单位。将每一个字节大小的内存单元以16进制从0开始逐一的进行标号，我们将这个标号称为这块内存单元的地址，也称之为指针。

什么是指针变量

顾名思义，存放指针的变量叫指针变量。

指向指针的指针

在C语言中指针的操作时通过指针变量来实现的，指针变量的本质也是一个变量，不同的是它存放内容是地址，既然是变量，那么它就有的内存地址，我们就同样可以定义一个变量来存放这个指针变量的地址：指向指针的指针

 int a = 10;
 int *p1;
 p1 = &a;
 int **p2;
 p2 = &p1;

上面的代码定义了一个一级指针变量p1，和一个二级指针变量p2，对**p2的操作就是对a的操作。

 **p2 = 100;
 printf("a = %d\n",a);

结果：a = 100;

这里要明确一下，这里只有三个变量，分别是a,p1,p2，*号数量的作用只是为了标识这个变量时一个几级指针变量，没有其他的意思。p2里存放的是p1的地址，p1里存放的是a的地址。通过对p2间接取地址操作，可以得到p1里面的内容。

建议理解方式，看到变量首先看这个指针变量是一个几级的指针变量，二级指针变量存放的是一级指针变量的地址，其次，看对这个指针变量进行什么操作，对一级指针变量进行一级间接寻址操作，表示的是对一级指针变量存放的地址所指向的内存单元进行操作，对二级指针变量进行一级间接寻址操作，表示的是对二级指针变量存放的地址所指向的内存单元进行操作。对二级指针变量进行二级间接寻址操作，则是按着指向链最终指向的内存单元进行操作。

几级指针变量看几级间接寻址操作。如果完全间接寻址，则指向最终内存单元里存放的内容。

//这里要插入图片

指向二维数组的指针

int *p[10];

上面的代码表示的是定义了一个指针数组p，首先要明确的是它是一个数组，里存放的是指针类型的数据

int (*p)[N];

上面的代码表示的是定义了一个指针，这个指针指向的是一个二维数组的第一行，这个二维数组一一共有N列。
如何理解记忆，首先（*P）表示的是强调，这个数据类型是一个指针，它不同于其他的指针，这个指针是以数据块作为移动的，这就是指向二维数组的指针。

##指向函数的指针

int (*p)(int ,char *);

什么意思呢？上面的代码是我们声明了一个指针变量p,这个变量指向了一个返回值为int类型的有两个参数第一个参数是int类型，第二个参数是指针类型的函数。

int *p(int ,char *);

当把括号去掉的时候，这句代码就发生了本质性的变化，上面的代码是定义了一个返回值为int *的函数。

指针小结：

• int i：定义一个整型变量
• int *p：定义一个指向int类型大小的内存单元的指针变量
• int a[10]：定义一个int型数组，内存单元大小10个int变量
• int (*p)[10]：定义一个数组指针，指向int [10]类型的指针变量
• int func( )：定义一个函数，返回值为int型
• int *p[10]：定义一个指针数组，其中每个数组元素指向一个int型变量的地址
• int *func( )：定义一个函数，返回值为int *型
• int (*p)( )：定义一个指向函数的指针，函数的原型为无参数，返回值为int
• int **p：定义一个指向int的指针的指针，二级指针
• int buf[3 ] [5]：二维数组名称，buf代表数组首地址

---

• int a[3][5];
• a[0], *(a + 0), *a：0行，0列元素地址
• a + 1：第1行首地址
• a[1], *(a + 1)：第1行，0列元素地址
• a[1] + 2, *(a + 1) + 2, &a[1][2]：第1行，2列元素地址
• (a[1] + 2), *( *(a + 1) + 2), a[1][2]：第1行，2列元素的值

C语言函数不能返回一个数组，想要返回一个数组，可以定义返回一个指针。
理解指针的关键是内存，没有，因为没有内存，哪来的地址，没有内存地址，和来的指针

案例一：

int a = 3;
int **p = NULL;
//如果我们将一个二级指针变脸赋值一个直接变量的地址，结果会怎么样呢？
p = &a;
//这个结果在编译的时候，是没有问题的。
//当我们使用的时候，就会出现问题，

/*
对于*p表示的是取p存放的内存地址所指向的内存单元的值，
*/
printf("*p = %d\n",*p);
/*
这句话将会输出一个3，
但是**p的结果就会有问题了。因为程序会输出以3为地址的内存单元的值，这个内存单元我们不一定有权限访问
*/

指针和数组的关系

int main(){
    char *p = malloc(sizeof(char) * 10);
    printf("%p\n",p);
    printf("%p\n",&p[0]);
}

分析：单纯的指针名字p表示的是数组首元素的地址。p和&p[0]是一样的意思，&p表示的是数组的地址，p[i]表示的是这个元素的值.如果想用指针表示数组元素的话，需要间接取地址符号：*(p+i);

int main()
{
    char **p = malloc(sizeof(char *) * 10);
   
    for(int i = 0;i<10;i++){

        p[i] = malloc(sizeof(char) *10）；
   
    }
}

分析：上面的代码表示的是：在堆内存中开辟了一个数组，这个数组里面存放的是指针，同时，每一个指针又，同时指向了另一篇数组空间：p:指针数组首元素的地址，p[i]表示的值指针数组的第i个元素，这个元素又是一个一级指针，p[i]的另一种表示是*（p+i).)`.

指针数组和二维数组的关系

int main() 
{
	char *str[] = { "adsfsdf","1234567894564","sdfsdfsd","dsfsdfsdfsdf" };
	printf("%d", sizeof(str));
	return 0;
}

结果：在32位系统下是16，在64位系统下是32，
分析：32位下，每一个地址占用4个字节带下，64位下，每一个地址占用8个字节大小。
这个结果表明：指针数组里面存放的是地址，并不是我们看到的值的内容。

char str[4][30] = { "adsfsdf","1234567894564","sdfsdfsd","dsfsdfsdfsdf" };

这里我们看到的是一个二维数组，这个二维数组可以看成（这里是看成，有些相似的地方）一个二级指针，但是又和指针有着很大的区别，
分析：

• 首先：str[0]可以看做一个一维数组，str[0]在指针的层面上是指向的是第一行的首地址。
  因此，str[0]也可以看做成为一个字符串指针．
• 不同的地方，在内存分配陪上是不同的，在第一种情况下，str中存放的是指针，第二种情况下，存放的 是一个真正的字符，它在栈上是开辟了空间的。
• str[0]虽然可一个看成是一个指针，但是它的又和字符指针不同，首先，它不是一个左值不可以通过指针赋值改变，然后他的的步长是根据列数和没个单元占用的字节数决定的。

只要是指针变变量，里面存放的是一定是一个内存地址，只有普通变量里面存放的才是值。

指针移动与指针步长

计算机中最小的存储单位是字节，每一个字节都有一个唯一的地址表示。

int a[]={1,2,3,4，5};
int *p = a;
printf("%p\n",p);
p++;
printf("%p\n",p);

结果我们可以看到两个地址相差4，这就表示指针的移动步长是4；恰好是一个int类型数据的内存空间。

char a[] = { 1,2,3,4,5 };
char *p = a;
printf("%p\n", p);
p++;
printf("%p\n", p);

结果我们可以看到两个地址相差1，这就表示指针的移动步长是1；恰好是一个char类型数据的内存空间。

char a[] = { 1,2,3,4,5 };
int *p = a;
printf("%p\n", p);
p++;
printf("%p\n", p);

这次我们使用int *p指向char a[],结果是两个地址相差4，

int a[] = { 1,2,3,4,5 };
char *p = a;
printf("%p\n", p);
p++;
printf("%p\n", p);

这次我们使用char *p指向int a[],结果是两个地址相差1，

总结：指针移动的步长，是由指针指向内存空间存放的数据类型决定的.

char a[] = { 1,2,3,4,5 };
char b[] = { 1,2,3,4,5 };
char c[] = { 1,2,3,4,5 };
char *p[] = { a,b,c};
char **p2 = p;
printf("%d\n", p2);
p2++;
printf("%d\n", p2);

根据上面的结论，我们猜想，二级指针移动的步长是多少呢？
分析：首先二级指针存放的是一级指针的内存空间的地址，这个地址是一个什么类型数据，又占用了多少内存单元呢？
这就区分了系统是32位还是64位了，首先32位的内存空间大小是2的32次幂，我们要想全部表示这些数字就必须用4个字节大小的数据来描述，也就是每一个地址时一个4字节大小的整数。同样的，64位的系统，就必须用8个字节大小的整数来表示了。所以运行的正确结果也就很明显，32位下是4，64位下是8；

总结：指针移动的步长就是指针变量指向的内存空间所存储的内容占用的字节大小。

指针做函数参数

间接赋值是指针存在的最大意义。使用N级指针改变N-1级指针的值

void func(int *p){
    int a = 1;
    *p = a;
}

int main(){
    int i =0;
    //改变i的值；
    func(&i);
}

void func(int **p){
    int a = 1;
    *p= a;
}

int main(){
    int i = 0;
    int *p = &i;
    //改变了p的值
    func(&p);
}

总结：如果一个函数的形参p是N级指针，则实参是N-1级指针，通过使用对形参的一级间接寻址(*p,对形参加一个*）来修改N-1级的值，实际上p就是N-1级指针的地址，对*p的修改就是修改实参N-1级指针变量的内容，从而修改指针指向。