【C语言】无废话指针

一、初识指针

1.1概念及演示

指针就是地址，指针变量就是存放地址的变量

（你可将地址理解为门牌号，找到门牌号就找到了你要找的人）

 示意代码如下：

	int a = 10;
	int* p = &a;//用p指向a的地址，a的类型是（int）所以p的类型是（int*）
	printf("a的地址：%p\n", p);//用%p打印当前p的地址
	int b = 12;
	p = &b;//改变p的指向，让p指向b的地址（&b 意思为b的地址）
	printf("b的地址：%p\n", p);
	printf("*p（b）的值：%d\n", *p);// * 号为解引用符号，*p表示的就是b
	printf("p（b的地址）的值：%d\n", p);//没有 * 号，p表示的是b的地址，用%d打印就会出错
	

1.2指针的大小和类型

int main()
{
	int* p1;
	long* p2;
	char* p3;
	float* p4;
    double*p5;
	//任何类型都可以定义为指针
}
//打印不同指针类型的大小
printf("%d\n", sizeof(p1));
printf("%d\n", sizeof(p2));
printf("%d\n", sizeof(p3));
printf("%d\n", sizeof(p4));
printf("%d\n", sizeof(p5));

我们可以看到：

指针的类型不同但大小都一样。

 

在64位（x64）机器下，指针的大小是8个字节

在32位（x86）机器下，指针的大小是4个字节

1.3指针类型的作用

指针类型决定了指针能够访问几个字节

int a = 12456;
int* p1 = &a;
char* p2 = &a;
printf("p1解引用：%d\n", *p1);//p1全访了a的地址

printf("p2接引用：%d\n", *p2);//p2只访问了a的地址的1/4
//指针的大小一样不代表它访问的内容也一样
	

所以当你使用上面的代码时，会产生如下结果：

二、野指针

2.1野指针定义

所指的位置不可知的指针成为野指针。

2.2野指针产生的原因

1.未初始化

2.指针越界访问

3.所致地址被释放

2.3防止野指针的方法

int* p;
p = NULL;//让野指针指向空（NULL为空）

printf("%p", p);//打印NULL的地址

让我们来看看NIULL的地址：

可以看到，NULL像是一个专门存放物品的全0空间，我们可以把指针放到这个空间，等到用时再拿出来。

三、指针运算

3.1指针与整数的加减运算

int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
int* p1=arr;
char* p2 = arr;
//这里打印地址会很直观
printf("p1的地址：%p\n", p1);
printf("p1+1的地址：%p\n", p1+1);
printf("p1+2的地址：%p\n", p1 + 2);
printf("\n");
printf("p2的地址：%p\n", p2);
printf("p2+1的地址：%p\n", p2+1);
printf("p2+2的地址：%p\n", p2 + 2);

 结果如下：

 原理：

 3.2指针-指针

指针相减的结果是以第一个指针大小为标准的两者之间的元素个数

 比如下面这段代码：

	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
	char* p1=&arr[5];
	int* p2 = &arr[1];//相减的指针必须指向同一空间
	printf("%d\n", p1 - p2);
	//没有 指针+指针 的形式

	int* p3 = &arr[5];
	char* p4 = &arr[1];
	printf("%d\n", p3 - p4);
	

运行结果如下：

原理： 

 

 3.3指针的关系运算

指针的关系运算实际上就是比较地址的大小

int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
int* p = &arr[0];
while (p<&arr[11])//这里超出arr了最大界限
{
	printf("%p\n", p);
	p++;// p=p+1 指针与整数的加减法
}

运行结果：  

这里可以看到指针是可以越界访问的，但不要这样做。

四、数组名 

1.1数组名的本质

数组名的本质其实就是一个指向元素首地址的指针。

 

int arr[5] = { 1,2 };
printf("%d", *arr);
//运行结果为：1

 既然数组名的本质是指针，那下面的代码也是合理的：

	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
	int* p = arr;

    //arr[i]==*(arr+i)
	printf("%d\n", *(arr+2));
	printf("%d\n", arr[2]);

     
    //p[i]==*(p+i)
	printf("%d\n", p[2]);
	printf("%d\n", *(p + 2));
}

  代码结果都是3

 1.2arr与原始的指针的区别：

int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
int* p = arr;//数组名表示首元素地址，指针可以直接接收

//以下两种情况例外
sizeof(arr);// sizeof(arr) 中的arr表示整个数组的地址
&arr;// &arr 表示整个数组的地址

//我们来测试一下
int ret1 = sizeof(arr);//sizeof用来测量传入数据的大小（字节）
int ret2 = sizeof(p);

printf("sizeof(arr)的打印结果：%d\n", ret1);//如果sizeof(arr)中arr代表整个元素地址，那打印结果应该是40
printf("sizeof(p)的打印结果：%d\n", ret2);//这里打印的是指针本身的大小，不是整个arr地址的大小
printf("arr[10]首元素的地址：%p\n", arr);
printf("&arr + 1的结果：%p", &arr + 1);//arr代表整个数组地址时，+1 会跳过1个arr数组

 运行结果：

 五、二级指针

二级指针就是指向指针的指针。

（三级指针就是指向指向指针的指针的指针，，，依次类推）

int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
int* p1 = arr;
int** p2 = &p1;//&p1表示p1这个指针自己本身的地址（不是p1指针指向的地址）
//p1的类型是(int*),所以二级指针p2的类型是(int**)
printf("%d\n", (*p2)[3]);
	//p2解引用解出来的是p1（*p2==p1）

运行结果：

六、数组指针和指针数组 

1.1数组指针

指向数组的指针。

int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
int(*p1)[5] = &arr;//此处必须有括号   
//此时的p1可以看作是指向arr中5个元素为一整体的指针
printf("%d\n", *(*(p+1)));//p指向5个元素，p+1会跳过5个元素
//我们可以这么理解 int(*)[]==&数组名 。

p1就是数组指针，输出的结果：

 1.2指针数组

存放指针的数组。

char* p1 = "abcdef";
char* p2 = "ghijkl";
char* p3 = "mnopqr";
char* arr[] = { p1,p2,p3 };//数组存放的是(char*)类型的指针，所以数组的类型也需要是(char*)
printf("%s\n", *(arr + 1));//*(arr+1)==arr[1]==p2

输出结果：

 注意：int*p[5]!=int(*p)[5]，前者是储存5个指针元素的数组，后者是p指向有5个元素的(int)数组的指针 。 

七、指针的参数

一级指针：int* p;

二级指针：int**p;

我们也可以将数组名看作一个指针

一维数组：int arr[];

二维数组：int arr[][num](行可省，列不可省);int(*p)[num];

八、函数指针 

1.1定义及演示

指向函数的指针。

int ADD(int a,int b)
{
	return a + b;
}

int main()
{
         // () 里放的是函数的参数
	int(*p)(int, int) = ADD;

	printf("%d\n",p(3, 5));
	printf("%d\n", (*p)(3, 5));// p 和 *p 没什么区别
           //**注意：(*p) 必须带括号，否者p会和[]匹配变成*(p[3,5])
}

运行结果：

1.2函数指针数组

存放函数指针的数组。（和数组指针很像）

int Add(int a,int b)
{
	return a + b;
}

int Sub(int a, int b)
{
	return a - b;
}

int Mul(int a, int b)
{
	return a * b;
}

int Div(int a, int b)
{
	return a % b;
}

int main()
{
	int(*p[4])(int,int) = {Add,Sub,Mul,Div};//和指针数组很像对吧
	printf("%d\n",p[2](3, 5));
	printf("%d\n",(*(p+0))(3, 5));//希望你没有忘记指针加减法
}

运行结果：(别忘了：数组第一个元素下标为0)

 1.3指向函数数组的指针

九、回调函数 

用人话将就是：被另一个函数调用的函数，称作调用函数

 举例qsort函数：

#include<stdlib.h>

//qsort是库函数，可以实现将传入的数组自动排序
//qsort具体内容在这里不做过多讲解，请自行查询

int Sort(const void*a,const void*b)//Sort就是回调函数
{
	return *(int*)a-*(int*)b;
}

int main()
{
	int arr[10] = { 2,5,4,8,6,5,4,6,6,5 };
	int(*cmp)(const void*, const void*) = Sort;
	qsort(arr, 10, 4, cmp);//传入回调函数的指针
	for (int i = 0; i < 10; i++)
	{
		printf("%d ", arr[i]);
	}
}