1.指针是什么

2.指针和指针类型

3.野指针

4.指针运算

5.指针和数组

6.二级指针

7.指针数组

1.指针是什么

为了更好地管理内存，把内存分为了1个个小小的内存单元，大小是一个字节，每个字节给一个编号，内存的编号就是地址，每个内存单元都有一个唯一的编号，这个编号也被称为地址。地址也叫指针，所以编号==地址==指针。

在我们写C语言程序时，创建变量，数组等都需要在内存上开辟空间。

注意：平时口头说的指针，通常指的是指针变量，是用来存放内存地址。

指针变量：

指针是一个变量，用来存放内存地址。可以通过&取地址符来得到变量的地址

#include<stdio.h>

int main()
{
	int a = 100;
	int arr[10] = { 0 };
	printf("%p\n", &a);

	//&a 取a的地址，pa是存放a的地址，这里的pa就被称为指针变量
	//int*  是pa的类型   * 说明pa是指针变量 int 说明pa是指向的是整形便来给你
	int* pa = &a;

	//指针变量在32位平台下是4个字节
	//指针变量在64位平台下是8个字节

	return 0;
}

总结：指针就是变量，用来存放地址的变量。（存放在指针中的值都被当成地址处理）。

那这里的问题是：

一个小的内存单元到底多大？（1个字节）
如何编址？

经过仔细的计算和权衡我们发现一个字节给一个对应的地址是比较合适的。

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

那么32跟地址线产生的地址就会是：

00000000 00000000 00000000 00000000

00000000 00000000 00000000 00000001

.....

111111111 111111111 111111111 111111111

这里就会产生2的32次方个地址。

每个地址标识一个字节，那我们就可以给2^32Byte == 2^32/1024KB == 2^32/1024/1024MB == 2^32/1024/1024/1024GB == 4GB 的空间进行编址。

同样的方法，那64位机器就可以给更大的空间编址。

这里我们就明白：

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

总结：

指针是用来存放地址的，地址是唯一标示一块地址空间的。
指针的大小在32位平台是4个字节，在64位平台是8个字节，与指针类型无关

#include<stdio.h>

int main()
{
	printf("%d\n", sizeof(char*));
	printf("%d\n", sizeof(short*));
	printf("%d\n", sizeof(int*));
	printf("%d\n", sizeof(long*));
	printf("%d\n", sizeof(float*));
	printf("%d\n", sizeof(double*));
	//指针变量在32位平台下都是4个字节
	//指针变量在64位平台下都是8个字节
	return 0;
}

2.指针和指针类型

变量有不同的类型，整形，浮点型等。那指针也有不同的类型。

int num = 10;
p = &num;

要将&num（num的地址）保存到p中，我们知道p就是一个指针变量，那它的类型是怎么样的呢？我们也给指针变量相应的类型。

char *p = NULL;
int *p = NULL;
short *p = NULL;
long *p = NULL;
float *p = NULL;
double *p =NULL;

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

指针类型的意义：

1.指针的权限

看下面一段代码

#include<stdio.h>
int main()
{
	int a = 0x11223344;//0x开头是16进制数字 0x11223344正好4个字节 可以把a放满  内存中数字倒着放
	char* pa = &a;
	*pa = 0;
	return 0;
}

我们可以通过调试F10，打开调试窗口中的内存可以看到下图

下图可以发现 int* 类型指针解引用可以访问4个字节

下图可以发现 char* 类型指针解引用可以访问1个字节

可以推出，short*可以访问2个字节，float*可以访问4个字节，double*可以访问8个字节

结论：指针类型可以决定指针解引用的时候访问多少个字节（指针的权限问题）。指针的类型决定了指针解引用的操作权限。

type* p * 说明p是指针变量
1. type是p指向的对象的类型
2.p解引用的时候访问的对象的大小sizeof(type)

2.指针加一的结果

结论：

指针类型决定指针+1或-1操作的时候步长，整形指针+1跳过4个字节，字符指针+1跳过1个

字

type * p， p加减n，跳过的是n*sizeof(type)个字节

3.野指针

概念∶野指针就是指针指向的位置是不可知的（随机的、不正确的、没有明确限制的）指针变量在定义时如果未初始化，其值是随机的，指针变量的值是别的变量的地址，意味着指针指向了一个地址是不确定的变量，此时去解引用就是去访问了一个不确定的地址，所以结果是不可知的。

野指针的成因：

1.指针未初始化

#include<stdio.h>

int main()
{
	int* p;//局部变量不初始化的时候，内容是随机值
	*p = 20;
	printf("%d\n", *p);
	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.指针指向的空间释放

#include<stdio.h>
int* test()
{
	//a的空间是进入函数创建 出函数还给操作系统
	int a = 100;
	return &a;//函数调用完局部变量a被销毁
}
int main()
{
	int* p = test();
	printf("%d\n", *p);//编译器做了一次保留,能打印
	printf("%d\n", *p);//这里就是野指针了，所以不能返回局部变量的地址
	return 0;
}

如何避免野指针：

1.指针初始化

2.小心指针越界

3.指针指向空间释放及时置NULL

4.指针使用之前检查有效性

4.指针运算

1.指针+-整数

#include<stdio.h>
int main()
{
	int arr[10] = { 0 };
	//不使用下标访问数组
	int* p = &arr[0];
	int i = 0;
	int sz = sizeof(arr) / sizeof(arr[0]);//数组元素个数
	for (i = 0; i < sz; i++)
	{
		*p = i;
		p++;
	}
	printf("\n");
	p = arr;//重置p
	for (i = 0; i < sz; i++)
	{
		printf("%d ", *(p + i));
	}
	return 0;
}

int arr[10];
int* p = arr;

这里：
*(p+i) == arr[i]
*(arr+i) == arr[i] arr[i]编译器会转换为*(arr+1)
arr是首元素地址是指针
*(arr+i) == *(i+arr) == i[arr]
i 和 arr只是[] 的操作数

2.指针-指针

指针减去指针得到的数值的绝对值是指针和指针之间的元素个数

#include<stdio.h>

int main()
{
	int arr[10] = { 0 };
	printf("%d\n", &arr[9] - &arr[0]);//9
	printf("%d\n", &arr[0] - &arr[9]);//-9
	//指针相减的前提是：两个指针指向了同一块空间
	return 0;
}

通过指针-指针实现strlen() 求字符串长度函数

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

int main()
{
	char arr[] = "abcdef";
	int len = my_strlen(arr);

	printf("%d\n", len);

	return 0;
}

3.指针的关系运算

#define N_VALUES 5

float values[N_VALUES];

float *vp;

for(vp = &values[N_VALUES]; vp > &values[0]; )

{

*--vp = 0;

}

代码简化，将代码可以修改如下

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

{

*vp = 0;

}

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

这两个循环的区别就是:第一段代码vp指针最开始指向整个数组后面的第一个元素，循环完指向数组的第一个元素。第二段代码vp指针最开始指向数组最后的一个元素，循环完指向整个数组前面的第一个元素

标准规定：

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

5.指针和数组

指针是指针变量，是大小4/8个字节，专门用来访问地址的

数组是一块连续的内存空间，可以存放1个或多个类型相同的数据

数组名是数组首元素的地址，数组名==地址==指针，数组是可以通过指针来访问的。数组是连续访问的，所以通过指针就可以遍历访问数组元素。

#include<stdio.h>

int main()
{
	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
	int* p = arr;
	int sz = sizeof(arr) / sizeof(int);
	for (int i = 0; i < sz; i++)
	{
		printf("%p == %p  %d\n", p+i,&arr[i],*(p+i));
	}
	return 0;
}

数组名表示首元素地址特殊情况：

1.&数组名

虽然这里得到得数值是和首元素地址数组名是相同的，但是它们+1的结果是不同的，&数组名+1是跳过整个数组，而数组名+1是数组的第二个元素。

2.sizeof(数组名）

sizeof(数组名) 表示的是整个数组所占内存空间的大小，单位是字节。

6.二级指针

一级指针存放变量的地址，二级指针存放一级指针的地址。

示例：

#include<stdio.h>

int main()
{
	int a = 10;
	int* p = &a;//p是一级指针变量，指针变量也是变量，
	//是变量就有地址，变量在内存中开辟空间的

	//二级指针变量存的是一级指针的地址
	int** pp = &p;//二级指针 pp是二级指针变量， 
	//int* 说明pp指向的内容是指针变量int*类型  最后一个*表示pp是指针
	
	int*** ppp = &pp;//三级指针
	//int** 说明ppp指向的内容是二级指针变量int**类型  最后一个*表示ppp是指针

	//通过二级指针访问a
	**pp = 100;
	printf("%d\n", a);//100

	return 0;
}

图解：

7.指针数组

整形数组是存放整形的数组，字符数组是存放字符的数组，而指针数组就是用来存放指针的数组

示例：

#include<stdio.h>

int main()
{
	int arr1[] = { 1,2,3,4,5 };
	int arr2[] = { 2,3,4,5,6 };
	int arr3[] = { 3,4,5,6,7 };
	
	//指针数组
	int* parr[] = {arr1,arr2,arr3};

	for (int i = 0; i < 3; i++)
	{
		for (int j = 0; j < 5; j++)
		{
			printf("%d ", parr[i][j]);
		}
		printf("\n");
	}

	//不是真正的二维数组
	//二维数组是连续存放的

	return 0;
}

结构如图所示