【C语言】指针初阶

指针是什么

对于指针是什么？
指针理解的2个要点：

1. 指针是内存中一个最小单元的编号，也就是地址
2. 平时口语中说的指针，通常指的是指针变量，是用来存放内存地址的变量

我们可以通过&（取地址操作符）取出变量的内存其实地址，把地址可以存放到一个变量中，这个变量就是指针变量。

#include <stdio.h>
int main()
{
 	int a = 10;//在内存中开辟一块空间
	int *p = &a;//这里我们对变量a，取出它的地址，可以使用&操作符。
    //a变量占用4个字节的空间，这里是将a的4个字节的第一个字节的地址存放在p变量
	//中，p就是一个之指针变量。
	return 0;
}

总的来是指针就是我们的地址，地址就是指针，而指针大小在32/64位平台上是为4/8的。这在我们的初始C语言中已经讲过了，这就不作过多阐述。若想了解更多地址的内容，请点击我吧。

指针和指针类型

这里我们在讨论一下：指针的类型
我们都知道，变量有不同的类型，整形，浮点型等。那指针有没有类型呢？
准确的说：有的。

char  *pc = NULL;
int   *pi = NULL;
short *ps = NULL;
long  *pl = NULL;
float *pf = NULL;
double *pd = NULL;

这里可以看到，指针的定义方式是： type + * 。
其实：
char* 类型的指针是为了存放 char 类型变量的地址。
short类型的指针是为了存放 short 类型变量的地址。
int 类型的指针是为了存放 int 类型变量的地址。

这里只是举例，指针有很多类型的，希望通过举例了解到指针类型的含义。

int main()
{
	int a = 10;
	char* pa = &a;
	int* pb = &a;
	printf("%p\n", pa);
	printf("%p\n", pa + 1);
	printf("%p\n", pb);
	printf("%p\n", pb + 1);
	return 0;
}

我们可以看到pa到pa+1只跳过了一个字节
pb到pb+1跳过了4个字节。
他们都跳过了自己类型的字节数。

总结 :指针的类型决定了指针向前或者向后走一步有多大（距离）。

int main()
{
    int a = 0x11223344;		//4个bit位一个16进制位 8bit=1字节 内存中倒放
    char* pc = &a;
    *pc = 0;
    printf("%x\n", a);
    return 0;
}

这里我们以地址的形式打印，发现char类型的指针改变了一个字节（解引用），而当我们以调试内存的方式打开的时候。

会发现我们的数据在存储中是倒着放的，而且访问一个字节的时候，改变的是低位44。其实在这里就涉及到了我们的数据的存储和大小端分辨了，大家感兴趣的可以去看一下本人另一个博客内容，点击查看数据存储

总结：指针的类型决定了，对指针解引用的时候有多大的权限（能操作几个字节）。

以上2个总结就说明了为什么指针大小都为4/8字节，为什么还有这么多指针类型。

请思考一下下面代码

int main()
{
	int arr[10] = { 0 };
	int i = 0;
	char * pa = &arr[0];
	for (i = 0; i < 10; i++)
	{
		*pa = i + 1;
		pa ++;
		//pa += 4；
	}
	for (i = 0; i < 10; i++)
	{
		printf("%d ", arr[i]);
	}
	return 0;
}

这里输出结果和我们预期不一样，是因为为什么的指针类型是char类型，一次解引用访问一个字节，而数组里每一个元素是4个字节的。依次我们得到了与预期不符的结果。那么，我将p++改成p += 4呢，这样输出结果就是预期值了，但是我们解引用操作仍然是访问一个字节，只是指针指向的位置从原本的一个字节到4个字节。

野指针

其实野指针并没有那么高大上，遥不可及的一样，其形成就是程序员对指针的不规范使用。

概念： 野指针就是指针指向的位置是不可知的（随机的、不正确的、没有明确限制的）

野指针成因：

1. 指针未初始化

#include <stdio.h>
int main()
{ 
 	int *p;//局部变量指针未初始化，默认为随机值
    *p = 20;
	return 0;
}

这里开辟了指针变量，并指向了一块空间，但这个空间没有任何初始值，是赋予的随机值。问题是你并不知道你指向的哪一块空间，解引用的时候就是非法访问。

2. 指针越界访问

#include <stdio.h>
int main()
{
    int arr[10] = {0};
    int *p = arr;
    int i = 0;
    for(i=0; i<=11; i++)
   {
        //当指针指向的范围超出数组arr的范围时，p就是野指针
        *(p++) = i;
   }
    return 0;
}

这里野指针的形成也是访问了不该访问的空间

3. . 指针指向的空间释放

int* test()
{
	int	a = 10;
	return &a;
}

int main()
{
	int* p = test()
	*p = 100;
	return 0;
}

这里主要是test的调用后，a的空间会被释放，但是p指针仍然指向这块空间，并访问，就出问题了。
这里在以后动态内存的开辟中会细讲。

如何防范野指针

1. 指针初始化
2. 小心指针越界
3. 指针指向空间释放，及时置NULL
4. 避免返回局部变量的地址
5. 指针使用之前检查有效性

值得注意的是当我我们的指针并不知道指向哪的时候，可以赋予NULL

#include <stdio.h>
int main()
{
    int *p = NULL;
    //....
    int a = 10;
    p = &a;
    if(p != NULL)
   {
        *p = 20;
   }
    return 0;
}

指针运算

1. 指针± 整数

2. 指针-指针

3. 指针的关系运算

指针± 整数

#define N_VALUES 5
float values[N_VALUES];
float *vp;
//指针+-整数；指针的关系运算
for (vp = &values[0]; vp < &values[N_VALUES];)
{
     *vp++ = 0;
}

指针-指针

int main()
{
	int arr[] = { 1,2,3,4,5 };
	int* p1 = arr;
	int* p2 = &arr[4];
	printf("%d", p2 - p1);
	return 0;
}

值得注意的是指针指向的是起始位置（最小的那一个地址）。
这里的指针-指针（地址-地址）得到的是指针之间的元素个数。这个的前提是

1. 2指针指向的是同一块大空间，并且指针是同一类型
2. 指针-指针得到的是指针之间的元素个数

有了这个用法后，我们就可以用指针-指针模拟出我们自己的strlen函数

int my_strlen(char *s)
{
       char *p = s;
       while(*p != '\0' )
              p++;
       return p-s;
}

指针的关系运算

#define N_VALUES 5
float values[N_VALUES];
float *vp;
for(vp = &values[N_VALUES]; vp > &values[0];)
{
    *--vp = 0;
}

实际在绝大部分的编译器上是可以顺利完成任务的，然而我们还是应该避免这样写，因为标准并不保证它可行。值得注意的是我们这里指向了数组的下标为5的元素，但这并不是野指针，因为我们并没有访问它。野指针的危害是在使用的时候。

标准规定

允许指向数组元素的指针与指向数组最后一个元素后面的那个内存位置的指针比较，但是不允许与
指向第一个元素之前的那个内存位置的指针进行比较。

指针和数组

#include <stdio.h>
int main()
{
 	int arr[10] = {1,2,3,4,5,6,7,8,9,0};
    printf("%p\n", arr);
    printf("%p\n", &arr[0]);
    return 0;
}

可见数组名和数组首元素的地址是一样的。

结论：数组名表示的是数组首元素的地址。
那么我们这样写代码

int arr[10] = {1,2,3,4,5,6,7,8,9,0};
int *p = arr;//p存放的是数组首元素的地址

既然可以把数组名当成地址存放到一个指针中，我们使用指针来访问一个就成为可能。

#include <stdio.h>
int main()
{
    int arr[] = {1,2,3,4,5,6,7,8,9,0};
    int *p = arr; //指针存放数组首元素的地址
    int sz = sizeof(arr)/sizeof(arr[0]);
    int i = 0；
    for(i=0; i<sz; i++)
   {
        printf("&arr[%d] = %p   <====> p+%d = %p\n", i, &arr[i], i, p+i);
   }
    return 0;
}

所以 p+i 其实计算的是数组 arr 下标为i的地址。
那我们就可以直接通过指针来访问数组。
如下：

int main()
{
 	int arr[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 0 };
	int *p = arr; //指针存放数组首元素的地址
 	int sz = sizeof(arr) / sizeof(arr[0]);
 	int i = 0;
 	for (i = 0; i<sz; i++)
 	{
 		printf("%d ", *(p + i));
 	}
 	return 0;
}

二级指针

指针变量也是变量，是变量就有地址，那指针变量的地址存放在哪里？
这就是 二级指针 。

int main()
{
	int a = 0;
	int* p = &a;			
	int** pp = &p;
	//**pp = 1;
	//printf("%d", a);
	return 0;
}

我们要注意每一个*的意义，先看int* p = &a; *说明p是指针，int说明指向的对象是int类型的。

同理我们看int** pp = &p; *说明pp是指针类型，int*说明指向的对象是int*类型的

对于二级指针
我们对pp解引用访问的是p的空间

int b = 20;
*pp = &b;//等价于 p = &b;

**ppa 先通过 *ppa 找到 pa ,然后对 pa 进行解引用操作： *pa ，那找到的是 a .、

**ppa = 30;
//等价于*pa = 30;
//等价于a = 30;

总的来说，二级指针指向的是一级指针的地址。

指针数组

指针数组是指针还是数组？
答案：是数组。是存放指针的数组。

即数组每一个元素是指针类型。

我们在上面知道了每一个*的意义，对于写指针数组就容易多了

int main()
{
	int arr[] = { 12,3,4,5,6 };
	int* p = arr;
	int i = 0;
	for (i = 0; i < 5; i++)
	{
		printf("%d=%d\n", arr[i], *(p + i));
	}
	return 0;
}

通过运行得知，二者本质是一样的。

int* p = arr;

我们解引用能访问数组元素
*（arr+i）这里的arr是首元素地址，而且我们定义了p指向arr首元素地址
所以*（arr+i）等价于*(p+i)，再根据我们上面的代码，得出

*（arr+i）等价于 *(p+i) 等价于 arr[i]

我们知道这个前提后再来看

int main()
{
	int arr1[] = { 1,2,3,4 };
	int arr2[] = { 4,5,6,7 };
	int arr3[] = { 4,5,6,8 };
	int* parr[] = { arr1,arr2,arr3 };
	int i = 0;
	int j = 0;
	for (i = 0; i < 3; i++)
	{
		for (j = 0; j < 4; j++)
		{
			printf("%d", parr[i][j]);
		}
	}
	return 0;
}

值得注意的是我们的parr数组里存的地址是每一个一维数组的首元素地址。我们便于理解可以理解为我们的二维数组，但只能是理解为二维数组，因为我们不能确保他们的空间是连续的。

arr[i]其实就是首元素地址加上下标的形式，[]只是操作符而已，编译器需要转成运算表达式才能得出结果，即*（arr+i），这才是我们访问数组元素的本质，都是通过指针来完成的。

当我们打印的时候为什么要用到2个[][]操作符？我们以parr[0][1]举例
parr[0]的本质是*（parr+0），访问的是arr1这个数组元素，而arr1是其数组的首元素地址。
parr[1]在前面的基础上就是arr[1]即访问arr1数组里面的下标为1的元素。