C语言—指针

指针是什么

在计算机科学中，指针是编程语言中的一个对象，利用地址，它的值直接指向存在电脑存储器中另一个地方的值。由于通过地址能找到所需的变量单元，可以说，地址指向该变量单元。因此，将地址形象化的称为“指针”。意思是通过它能找到以它为地址的内存单元。

内存：

内存是一块大的空间4G/8G，通过把内存划分成一个个内存单元从而可以有效的管理内存，这里的一个个格子就是一块内存单元（大小为1字节），而为了更好的管理内存单元又给每个内存单元进行编号（编号在内存中称为内存单元的编号（内存单元的地址（地址效仿了生活中对编号的认识（叫法））））。通过内存单元的编号（内存单元的地址）就可以找到内存单元，也就是说内存单元的地址指向了该内存单元所以把内存地址也形象的称为指针（内存单元的编号、内存单元的地址、指针说的是同一个东西）

内存单元的编号产生的过程：如果是32位机器通电之后会产生电信号（有正电和负电），电信号最终会转化成数字信号之后，其实就是32个由0、1组成的二进制序列，那32位二进制序列有2^32种可能性的编号，这其中产生的所有编号就可以被当成内存单元的编号。

指针

将内存单元的地址存起来需要一个变量，这个变量是用来存放地址的也是用来存放指针的，所以把这个存放地址（指针）的变量称为指针变量（一般称为指针但实际是指针变量）。

指针是个变量，存放内存单元的地址（编号）。

指针是编号也是地址

指针的使用：

int main()
{
	int a = 10;//在内存中开辟一块空间   a占4个字节 - 
	int * pa = &a;//拿到的是a的4个字节中第一个字节的地址
	*pa = 20;

	return 0;
}

总结：

• 指针就是变量，用来存放地址的变量。（存放在指针中的值都被当成地址处理）。
• 一个小的内存单元为1个字节

对于32位的机器，假设有32根地址线，那么假设每根地址线在寻址的是产生一个电信号正电/负电（1或者0），那么32根地址线产生的地址就会是：

00000000 00000000 00000000 00000000
00000000 00000000 00000000 00000001
...
11111111 11111111 11111111 11111111

这里就有2的32次方个地址。每个地址标识一个字节，那就可以给 （2^32Byte == 4GB） 4G的空间进行编址。

同样的方法，那64位机器，如果给64根地址线，那就可以给8G的空间进行编址。

注：

• 在32位的机器上，地址是32个0或者1组成二进制序列，那地址就得用4个字节的空间来存储，所以一个指针变量的大小就应该是4个字节。
• 那如果在64位机器上，有64个地址线，那一个指针变量的大小是8个字节，才能存放一个地址。

总结：
1.指针是用来存放地址的，地址是唯一标示一块地址空间的。
2.指针的大小在32位平台是4个字节，在64位平台是8个字节。

指针和指针类型

指针的定义方式是： type + *

指针类型的使用：

char* 类型的指针是为了存放 char 类型变量的地址。
float* 类型的指针是为了存放 float 类型变量的地址。
int* 类型的指针是为了存放int 类型变量的地址。

指针变量不管是什么类型的指针变量，大小都是4个字节，指针类型是不是没用？！

指针类型的意义

指针的解引用

int main()
{
	//0 1 2 3 4 5 6 7 8 9 a b c d e f
	//4个二进制位可以表示一个16进制位
	int a = 0x11223344;
	char* pc =(char*) &a;
	*pc = 0;
	return 0;
}

图解：

注：指针类型决定了指针解引用的权限有多大

指针±整数

#include<stdio.h>
int main()
{
	int arr[10] = { 0 };
	int* p = arr;
	char* pc = (char*)arr;
	printf("%p\n", p);
	printf("%p\n", p + 1);
	printf("%p\n", pc);
	printf("%p\n", pc+ 1);
	return 0;
}

注：指针的类型决定了指针向前或者向后走一步有多大（距离）

总结：

1. 指针的类型决定了，对指针解引用的时候有多大的权限（能操作几个字节）。 比如： char* 的指针解引用就只能访问一个字节，而 int* 的指针的解引用就能访问四个字节。
2. 指针的类型决定了指针向前或者向后走一步有多大（距离）。

指针的使用：

如果希望访问数组的时候是按照整形元素的方式来访问这个数组的话，最好交给一个整形指针。因为整形指针走一步跳过一个整型，解引用也是访问一个整型的。如果希望这个数组要一个字节一个字节对它进行操作，虽然是个整型数组但希望它的每个字节都被指定成想要的内容这时就需要用字符指针去维护

注意：指针变量跳过几个字节取决于指针变量的类型的，跟指针指向的对象无关，跟指针变量被赋值的值也没有关系

野指针

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

野指针成因

实例一： 指针未初始化

int main()
{
	int* p;//p是一个局部的指针变量，局部变量不初始化的话，默认是随机值
	*p = 0;//非法访问
	//p为野指针
	return 0;
}

p指针里面存的是随机值，p指针里面的地址所指向的空间不一定是用户的

注：内存空间是用户申请走了分配给用户才是用户的，用户才可以访问这块空间，而用户没有去申请是不能随便访问的

实例二：指针越界访问

int main()
{
	//越界访问
	int arr[10] = { 0 };
	int* p = arr;
	int i = 0;
	for (i = 0; i <= 10; i++)
	{
		*p = i;
		p++;
	}
	
	return 0;
}

注：当指针p指向的范围超出数组arr的范围时，p就是野指针

实例三：指针指向的空间释放

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

int main()
{
	int*p = test();
	*p = 20;

	return 0;
}

注：指针p所指向的空间被释放掉，归还操作系统了不属于用户。但p指针内还存储之前释放空间的地址，如果访问了会造成野指针问题，p指针就是野指针

如何规避野指针

1. 指针初始化

int main()
{
	//当前不知道p应该初始化成什么地址的时候，直接初始化为NULL
	int* p = NULL;
	//明确知道初始化的值
	int a = 10;
	int* ptr = &a;

	return 0;
}

2. 小心指针越界
3. 指针指向空间释放及时置成NULL
4. 指针使用之前检查有效性

int main()
{
	int* p = NULL;

	if(p != NULL)
		*p = 10;

	return 0;
}

注：

• NULL空指针的本质是0，使用NULL时需要引入头文件stdio.h
  
• C语言本身是不会检查数组的越界行为的
• NULL（0地址）所指向的空间是不属于用户的（没有分配给用户），不能直接使用它。如果是使用了会造成野指针问题

指针运算

指针±整数

实例一：

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

上面这段代码作用是初始化数组

注：

• 数组随着数组下标的增长，地址是由低到高变化的
• 后置自增操作符比间接访问操作符优先级高

实例二：

指针-指针

实例一：

int main()
{
	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
	char c[5];
	//指针和指针相减的前提：两个指针指向同一块空间

	//printf("%d\n", &arr[9] - &c[0]);//err

	printf("%d\n", &arr[9] - &arr[0]); //9

	return 0;
}

注：

• 指针和指针相减的前提：两个指针指向同一块空间
• 指针-指针得到的两个指针之间的元素个数
• 指针+指针是毫无意义的

实例二：strlen函数的模拟实现

//计数器
int my_strlen(char* str)
{
	int count = 0;
	while (*str != '\0')
	{
		count++;
		str++;
	}
	return count;
}

//递归
int my_strlen(char* str)
{
	if (*str == '\0')
		return 0;
	return 1 + my_strlen(str + 1);
}

//指针-指针
int my_strlen(char* str)
{
	char* start = str;
	while (*str != '\0')
	{
		str++;
	}
	return str - start;
}

int main()
{
	//strlen(); - 求字符串长度
	int len = my_strlen("abc");
	printf("%d\n", len);//3

	return 0;
}

注：字符串作为实参传参的时候传递过去的不是字符串而是字符串首字符的地址

指针的关系运算

实例：

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

//代码简化, 这将代码修改如下：

for(vp = &values[N_VALUES-1]; vp >= &values[0];vp--)
{
	*vp = 0;
}

实际在绝大部分的编译器上是可以顺利完成任务的，然而还是应该避免这样写，因为标准并不保证它可行。

第二种写法大部分编译器下也能运行成功，但是应该避免这样的去写。因为有的编译器可能并不支持这样的去写，或者这样写会带来一定的问题

注：C语言标准规定，允许指向数组元素的指针与指向数组最后一个元素后面的那个内存位置的指针比较，但是不允许与指向第一个元素之前的那个内存位置的指针进行比较。

指针和数组

实例一：

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

总结：数组名表示的是数组首元素的地址。

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

p指针指向的是数组首元素的地址，首元素地址+i产生的就是下标为i这个元素的地址。所以p+i 其实计算的是数组 arr 下标为i的地址。就可以直接通过指针来访问数组。

实例二：

int main()
{
	int arr[10] = { 1,2,3,4,5,6,7,8,9,10};

	int* p = arr;//数组名
	printf("%d\n", arr[2]);
	printf("%d\n", p[2]);//p[2] --> *(p+2)

	//[] 是一个操作符  2和arr是两个操作数
	//加法支持交换律   a+b   b+a
	
	//之所以支持2[arr]这样写是因为arr[2]这种写法最终编译器运算的时候它会转换成*(arr+2)，因为加法支持交换律的，能写成*(2+arr)最终写成2[arr]
	printf("%d\n", 2[arr]);
	printf("%d\n", arr[2]);

	//arr[2] --> *(arr+2)-->*(2+arr)-->2[arr]

	//arr[2] <==> *(arr+2) <==> *(p+2) <==> *(2+p) <==> *(2+arr) <==> 2[arr]
	//2[arr] <==> *(2+arr)
	return 0;
}

二级指针

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

实例：

int main()
{
	int a = 10;
	int* pa = &a;//pa是指针变量，一级指针

	//ppa就是一个二级指针变量
	int ** ppa = &pa;//pa也是个变量，&pa取出pa在内存中起始地址
	int*** pppa = &ppa;  //三级指针

	return 0;
}

对于二级指针的运算有：

• *ppa 通过对ppa中的地址进行解引用，这样找到的是 pa ， *ppa 其实访问的就是 pa

int b = 20;
*ppa = &b;//等价于 pa = &b;

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

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

指针数组

指针数组本质是数组是存放指针的数组。

//指针数组 - 数组

int main()
{
	int arr[10];//整形数组 - 存放整形的数组就是整形数组
	char ch[5];//字符数组 - 存放的是字符
	//指针数组 - 存放指针的数组
	int* parr[5];//整形指针的数组     parr是一个数组，有五个元素，每个元素是一个整形指针
	char* pch[5];//字符指针数组       pch是一个数组，有五个元素，每个元素是一个字符指针

	return 0;
}