C语言指针

前言：

指针是一个变量，其值为另一个变量的地址。就像其他变量或常量一样，您必须在使用指针存储其他变量地址之前，对其进行声明。

要理解指针就要先理解计算机的内存。计算机内存会被划分为按顺序编号的内存单元。每个变量都是存储在内存单元中的，称之为地址。

 

指针是一个变量，所以可以使用任何合法的变量名。在大多数的操作系统上，程序不允许访问地址为 0 的内存，因为该内存是操作系统保留的。

然而，内存地址 0 有特别重要的意义，它表明该指针不指向一个可访问的内存位置。

但按照惯例，如果指针包含空值（零值），则假定它不指向任何东西。

所有指针在创建时都要初始化，如果不知道他指向什么就将 0 赋值给他。必须初始化指针，没有被初始化的指针被称为失控指针(野指针）。

#include <stdio.h>
#include<Windows.h>
int main ()
{
    int *p = 0;
    int a ;
    p = &a;
    printf ("输入一个数字\n");
    scanf ("%d",p);
    printf("%d\n",*p);
	system("pause");
	return 0;
}

实例定义了变量 a 和指针变量 p。p = &a;表示指针变量指向了变量 a，p 中存放的地址为 a 的地址 &a，*p 所指的是 p 中存放的地址 a 内存单元中的值

• int p; -- 这是一个普通的整型变量
•  int *p; -- 首先从 p 处开始,先与*结合,所以说明 p 是一个指针, 然后再与 int 结合, 说明指针所指向的内容的类型为 int 型。所以 p 是一个返回整型数据的指针。
•  int p[3] -- 首先从 p 处开始,先与[] 结合,说明 p 是一个数组, 然后与 int 结合, 说明数组里的元素是整型的, 所以 p 是一个由整型数据组成的数组。
•  int *p[3]; -- 首先从 p 处开始, 先与 [] 结合, 因为其优先级比 * 高,所以 p 是一个数组, 然后再与 * 结合, 说明数组里的元素是指针类型, 然后再与 int 结合, 说明指针所指向的内容的类型是整型的, 所以 p 是一个由返回整型数据的指针所组成的数组。
•  int (*p)[3]; -- 首先从 p 处开始, 先与 * 结合,说明 p 是一个指针然后再与 [] 结合(与"()"这步可以忽略,只是为了改变优先级), 说明指针所指向的内容是一个数组, 然后再与int 结合, 说明数组里的元素是整型的。所以 p 是一个指向由整型数据组成的数组的指针。
•  int **p; -- 首先从 p 开始, 先与 * 结合, 说是 p 是一个指针, 然后再与 * 结合, 说明指针所指向的元素是指针, 然后再与 int 结合, 说明该指针所指向的元素是整型数据。由于二级指针以及更高级的指针极少用在复杂的类型中, 所以后面更复杂的类型我们就不考虑多级指针了, 最多只考虑一级指针。
•  int p(int); -- 从 p 处起,先与 () 结合, 说明 p 是一个函数, 然后进入 () 里分析, 说明该函数有一个整型变量的参数, 然后再与外面的 int 结合, 说明函数的返回值是一个整型数据。
•  int (*p)(int); -- 从 p 处开始, 先与指针结合, 说明 p 是一个指针, 然后与()结合, 说明指针指向的是一个函数, 然后再与()里的 int 结合, 说明函数有一个int 型的参数, 再与最外层的 int 结合, 说明函数的返回类型是整型, 所以 p 是一个指向有一个整型参数且返回类型为整型的函数的指针。
•  int *(*p(int))[3]; -- 可以先跳过, 不看这个类型, 过于复杂从 p 开始,先与 () 结合, 说明 p 是一个函数, 然后进入 () 里面, 与 int 结合, 说明函数有一个整型变量参数, 然后再与外面的 * 结合, 说明函数返回的是一个指针, 然后到最外面一层, 先与[]结合, 说明返回的指针指向的是一个数组, 然后再与 * 结合, 说明数组里的元素是指针, 然后再与 int 结合, 说明指针指向的内容是整型数据。所以 p 是一个参数为一个整数据且返回一个指向由整型指针变量组成的数组的指针变量的函数。

int board[8][8];    /* int 数组的数组 */ 
int ** ptr;         /* 指向 int 指针的指针 */
int * risks[10];    /* 具有 10 个元素的数组, 每个元素是一个指向 int 的指针 */
int (* rusks) [10];  /* 一个指针, 指向具有 10 个元素的 int 数组 */
int * oof[3][4];    /* 一个 3 x 4 的数组, 每个元素是一个指向 int 的指针 */ 
int (* uuf) [3][4]; /* 一个指针, 指向 3 X 4 的 int 数组 */
int (* uof[3]) [4]; /* 一个具有 3 个元素的数组, 每个元素是一个指向具有 4 个元素的int 数组的指针 */ 

指向函数的指针

代码和数据是一样的，都需要占据一定内存，那当然也会有一个基地址，所以我们可以定义一个指针来指向这个基地址，这就是所谓的函数指针。

double func(int a,char c);
double (*p)(int a,char c);
p=&func;

可以定义一个函数指针。

double s1=func(100,'x');
double s2=(*p)(100,'x');

上面两个语句是等价的。

函数指针形式的传递，实质却是地址传递的一个例子：

#include <stdio.h>
#include<windows.h>
void func1(int *a, int **b);

void func1(int *a, int **b)
{
   (*a)++;
   (*b)++;//这里虽然传进来的是指针的形式，但其实是指针c的地址，
          //可以认为这里本质还是值传递，只不过这个值是地址值
}

int main()
{
    int a[2] = {10, 20};
    int *b = &a[0];
    int *c = a+1;
    int **d = &c;
    
    func1(b, d);
    printf("a[0] = %d   a[1] = %d\n", a[0], a[1]);
    system("pause");
    return 0;
}

执行结果：a[0] = 11 a[1] = 20

由上可知，虽然传递参数时，是以指针形式进行的，但有时候会发现其实还是值传递，是地址值的传递，特别是在多维数组进行参数传递的时候，特别容易出现这种情况。

数组指针

给定义好的数组中赋值时, 指针可以通过调整地址给数组赋值。

例: 创建一个包含 3 个元素的一维数组, 并给它赋值。

int* array0 = (int*)malloc(sizeof(int) *3);
for(int i=0; i<3; i++){
    scanf("%d", array0+i);
}

• 内存是线性的，内存以地址空间的形式呈现给我们看的，所以可以说所谓的地址空间也是线性的，指针存放的是内存地址，所以你可以对地址做 ++，或者 -- 这样的运算。
•  两个指针不赋 NULL，是坏习惯
•  初始化指针不赋 NULL，因为这样的指针会指向一片未知的区域，这样的指针不是空指针，但指向一片访问受限制的内存区域，你无法使用它，这样的情况下的指针，业界给了它一个形象的名字：“野指针”，而且难以调试，在许多编译器单步 debug 会出现奇怪的错误，但经常看见的 "Segmentation Fault" 这样的错误，实测当代码多的时候，这是一个非常蛋疼的错误，野指针就是成因之一，所以看到这样的错误，首先是想想，是否有某些指针没有初始化引起的
•  free() 后指针不赋 NULL，为指针分配内存后，指针便可以指向一片合法可使用的内存，但使用 free() 释放那片内存时，指针依旧存放着那片内存的地址，也就是依旧指向那片内存，但这片内存已经释放，不可访问，这时若不小心使用了这个指针，便会内存错误，又是会有奇怪的 bug ，代码几百行多点就会难以调试，业界给这样的指针也有个统称：“悬空指针”，为了避免这种蛋疼的情况出现，一定要释放内存后，给指向这片内存的指针，都赋值为 NULL，从中也可以看出，free() 这个函数释放内存时跟指向这片内存的指针并没有什么卵关系，不会连着把指针一起搞定掉的！ 珍爱生命，远离 "野指针" 与 "悬空指针" ！
•  多级指针，指向指针的指针，有时人们也管它叫多维指针。既然指针变量是一个变量，指针变量能存变量的内存的地址。

像 int * 存 int 型变量的地址，char * 存 char 型的地址，那指针理所当然可以存指针变量的地址啊。

例如，int ** 存 int * 的地址，int *** 存 int ** 的地址。

这就是一个二级指针存一级指针的地址，三级指针存二级指针的地址，人们把这样的过程叫指向指针的指针，但其实也就是一个上一级的指针存了下一级的指针的地址而已。

因此，像上面说的，你存了它的地址，你就是指向它，所以：

•  二级指针存一级指针的地址，那么可以说二级指针指向一级指针
•  三级指针存二级指针的地址，那么可以说二级指针指向一级指针