不再恐惧指针，指针详解

什么是指针？

通俗来说指针就相当于地址，因为我们写入的代码每个变量的数据类型不同，字节大小不同，在计算机内存中所开辟存储的大小自然不同，且指针通常存储的是内存单元中最小单元的编号

比如：int*指针的大小是4个字节，在内存存储地址分别为0x11223344 0x11223355 0x11223366 0x11223377，那么int*指针存储的就是0x11223344内存地址(内存地址是我随便编的，因为在计算机中内存存储中地址是计算机随机分配的地址)

#include<stdio.h>
int main()
{
	int a = 10;
	//%p是用来打印地址的
	//&a取地址符号
	printf("%p\n", &a);
	return 0;
}

在内存中的分配

每个内存都有自己对应的唯一编号，编号==地址==指针，在写代码时创建的变量、数组、结构体等都要在内存上开辟空间。

为什么一个内存单元字节要设置为1个字节呢？

经过前人的不断钻研和计算，发现给内存单元一个字节大小是最优解。

在32位的计算机上有32根物理地址线，在32根地址线在寻找地址的时候产生高电平(1)和低电平(0)

就是二进制的1和0 那么它们能产生的地址如下：

也就是2^32次方 2^32=4294967296字节 能够管理4294967296内存字节空间

差不多4GB多一点内存空间

这就是为什么64位机器比32位机器内存空间大 比32位机器寻址能力强

在进行复杂的数据处理时，性能强 速度快等优点。

#include<stdio.h>
int main()
{
	//在内存中开辟4个字节大小
	int a = 10;
	//int*的指针变量 通过&取地址将a中4个内存单元中最小字节存储到了指针变量p中
	int* p = &a;
	printf("%p\n", &a);
	printf("%p\n", p);
	return 0;
}

p就是一个指针变量，用来存放地址的变量。

指针大小

通过32位机器中32根地址线和64位机器中64根地址线，就能发现指针大小不同。

一般在32位机器中不管指针变量存储的是什么数据类型的地址，大小都为4个字节

一般在64位机器中不管指针变量存储的是什么数据类型的地址，大小都为8个字节

VS2019 32位环境编译

#include<stdio.h>
int main()
{
	
	printf("%d\n", sizeof(int*));
	printf("%d\n", sizeof(char*));
	printf("%d\n", sizeof(short*));
	printf("%d\n", sizeof(double*));
	printf("%d\n", sizeof(long long*));
	return 0;
}

VS2019 64位环境编译?

指针和指针类型

在创建变量中，系统提供的内置类型有很多，比如int、short、double...等，那么指针也有类型吗？

指针也有对应的指针类型，也是整形，浮点型等，因为指针存储的就是变量的地址。

#include<stdio.h>
int main()
{
	
	int a = 0x11223344;
	int* pa = &a;
	*pa = 0;
	return 0;
}

?

我们可以看见不同类型指针变量，能够解引用*操作的空间与指针类型有关。

int*的指针解引用4个字节? char*的指针解引用1个字节

总结：指针类型决定了指针解引用的操作权限。

(也就是指针解引用访问多少个字节空间取决于指针类型)

Type*p

*p表明是一个指针变量 p指向的对象类型是Type? p解引用的时候访问对象大小是sizeof(Type)。

int*pa=&a 的意思是 *p表明是一个指针变量? p指向的对象类型是int? ?

p解引用访问的对象大小字节是int(4个字节)

#include<stdio.h>
int main()
{
	
	int a = 0x11223344;
	int* pa = &a;
	char* pb = (char*)&a;
	printf("%p\n", pa);
	printf("%p\n", pa+1);
	printf("%p\n", pb);
	printf("%p\n", pb+1);

	return 0;
}

C4到C8是4个字节大小 C4到C5是一个字节大小?

总结：指针的类型决定了指针向前或者向后走一步有多大(距离)?。

什么是野指针

野指针：野指针就是指针指向的位置是未知的(随机的，不正确的，没有明确限制的)。

比如野狗就是野指针，没有主人，它就没有温暖的家，只能四处流浪。

*p就相当于野狗具有危险性?

*p1=NULL 相当于野狗拴上了狗链子，危险性大大降低。?

野指针是怎么形成的？

1.指针没有初始化

#include<stdio.h>
int main()
{
	
	int* p;
	int a = 10;
	*p = a;
	return 0;
}

在*p没有初始化，局部变量没有初始化，希望默认为随机值，一般不知道指针变量要指向哪个变量，就置为空即可(NULL)。

在C语言中NULL就是0

2.指针越界访问

#include<stdio.h>
int main()
{
	
	int arr[5] = { 0 };
	int* p = arr;
	int i = 0;
	for (i = 0; i <= 5; i++)
	{
		*(p++) = i;
	}
	return 0;
}

??

当指针指向的范围超出了数组arr范围时，就会造成野指针，因为数组arr总共就5个数，数组下标从0到4，而for循环的判断条件却是小于等于5，超出数组原本的范围，形成了数组越界访问，造成野指针的形成。在VS2019编译器会帮忙检查越界，不同编译器不同，如果你在工作时编译器不会帮你检查越界问题，而代码运行不起来时,你就要开始自己疯狂挠头了！所以要避免野指针的形成。

3.指针指向的空间释放

在动态内存管理malloc realloc? calloc free，忘记free开辟的动态内存空间，一般情况下不用释放也行，虽然不释放形成了野指针，但只要没有人用就没有危险，但一般动态内存开辟使用完，记得free也是一个好习惯。

避免野指针的形成

1.指针初始化

2.小心指针越界

3.指针指向空间free释放置为空

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

#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
int main()
{
	//指向初始化
	int* p = NULL;
	p = (int*)malloc(sizeof(20));
	if (p == NULL)//使用之前检查有效性(是否为空)
	{
		perror("malloc fail");
		exit(-1);
	}
	//p!=NULL
	*p = 20;
	printf("%d\n", *p);

	free(p);
	p = NULL;
	return 0;
}

指针和数组

指针和数组虽然是两个不同的东西，但它们俩之间却有着千丝万缕的联系。

#include<stdio.h>
int main()
{
	int arr[10] = { 0 };
	int* p = &arr[0];
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		*p = i;
		p++;
	}
	for (i = 0; i < 10; i++)
	{
		printf("%d ", arr[i]);
	}
	return 0;
}

首先我们要注意：数组名原则上会被解释为指向该数组起始元素的指针

但有两种情况下，数组名不会为视为指向起始元素的指针。

1.作为sizeof运算符的操作数出现时

sizeof(数组名)不会生成指向起始元素的指针的长度，而是生成数组整体的长度。

2.作为取地址运算符&的操作数出现时

&数组名不是指向起始元素的指针的指针，而是指向数组整体的指针。

在数组中，数组名arr和&arr[0]的地址是相同，既arr的值就是arr[0]的地址，既&arr[0]。

不管arr的元素有多少个，只要元素类型有Type型，arr的表达式类型就是Type*。

而在两个例外中可以发现，sizeof数组名是整个数组的长度，不再是指针。

而取地址数组名，是指向的不是数组首个元素，而是指向整个数组整体的指针。

&arr+1 可以发现B0到D8，正好是数组10个元素的字节长度40。

将数组名视为指针，也催生出了数组和指针的密切关系。

指针的初始值是&arr[0],写成arr也是一样的，指针p被初始化为指向数组arr的起始元素arr[0];

*p既然指数组首个元素的值，通过指针本身p++遍历数组，将自己的值赋值给数组，打印出了0~9。?

指针运算符和下标运算符

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

?如果将指向数组内元素p+i前写上解引用操作符*会怎么样呢？

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

我们看见arr[i]==*(arr+i)? p+i==*(p+i)

由此我们可以推断 arr[0]==*(arr+0)? arr[1]==*(arr+1) ....

通过交换律我们发现*(p+i)==*(i+p)? 这样一看是不是p[i]可以写成i[p]呢？

答案是可以的！

因为[]下标运算符，是一个具有两个操作数的双目运算操作符，下标运算符[]的操作数顺序是随意的

就像1+2==2+1一样，arr[1]和1[arr]也是等价的。

所以我们可以写成arr[i]? i[arr]? *(i+a)? *(a+i)? ?p[i]? i[p] ....

但为了让别人看起来简洁高效，最好不要使用i[arr]等容易出现错误的写法。

指针运算??

指针+-整数

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

指针-指针

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

指针减去指针得到的数值是：指针和指针之间的元素。

指针-指针的前提是：指针和指针指向了同一块空间?。

指针之间可以相减但不能相加

二级指针

指针变量也是变量，是变量就要开辟内存空间，就会有所对应的地址。

#include<stdio.h>
int main()
{
	int a = 20;
	int* p = &a;
	int** pp = &p;

	*(*pp) = 100;

	printf("%d\n", a);
	
	return 0;
}

int* *pp=&p *pp表示是一个指针变量 再通过解引用保存p的地址

*(*pp)? *pp就是访问的就是p 再通过解引用操作 访问到*p的整个空间区域?就是a

因此最后结果是100。

指针数组

指针数组是指针？还是数组？

是数组！是存放指针的数组。

整形数组和字符数组

整形数组：存放整形的数组

字符数组：存放字符的数组

?指针数组

#include<stdio.h>
int main()
{
	char arr1[] = "abc";
	char arr2[] = "bcd";
	char arr3[] = "adas";

	char* parr[] = { arr1,arr2,arr3 };
	int i = 0;
	for (i = 0; i < 3; i++)
	{
		printf("%s\n", parr[i]);
	}
	
	return 0;
}

parr存储三个字符数组，再通过解引用保存各数组首元素值的地址，再用for循环打印出来，因为printf具有链接性，只要知道首个元素的地址就能将后面直至\0之间的内容都自动打印出来。

指针数组就是存放指针(地址)的数组。

其实通过上面的例子，我们可以变相的用指针数组模拟实现二维数组。?

int* parr[3]是什么意思？? parr[3]是一个数组，里面有3个元素，每个元素是一个整形指针。

#include<stdio.h>
int main()
{
	int arr1[] = { 1,2,3 };
	int arr2[] = { 4,5,6 };
	int arr3[] = { 7,8,9 };

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

数组指针

数组指针是数组？还是指针？

是指针！

int*p是指向整形数据的指针

float*p1是指向浮点型数据的指针

那么数组指针：就是指向数组的指针

以下两种，哪个才是数组指针？

?int(*p1)[10]才是数组指针，因为下标操作符[]的优先级高于解引用*的符号的优先级，如果不加括号p就先会和[]先结合，变成了指针数组。为了避免这种情况，为了解引用先生效，要先加括号。

因此int(*p1)[10]才是一个指向数组的指针，指向的数组大小为10，p1是一个指针变量，指向一个数组。

数组指针既然指向的数组，那数组指针存放的应该是数组的地址。

但一般我们写代码时，很少这样使用数组指针。

一般是在二维数组传参时，才使用数组指针。

#include <stdio.h>
void print_arr1(int arr[3][5], int row, int col)
{
	int i = 0;
	for (i = 0; i < row; i++)
	{
		int j = 0;
		for (j = 0; j < col; j++)
		{
			printf("%d ", arr[i][j]);
		}
			printf("\n");
	}
}
void print_arr2(int(*arr)[5], int row, int col)
{
	
	int i = 0;
	for (i = 0; i < row; i++)
	{
		int j = 0;
		for (j = 0; j < col; j++)
		{
			printf("%d ", arr[i][j]);
		}
		printf("\n");
	}
}
int main()
{
	int arr[3][5] = { 1,2,3,4,5,6,7,8,9,10 };
	print_arr1(arr, 3, 5);
	print_arr2(arr, 3, 5);
	return 0;
}

二维数组其实本质就是一维数组。

二维数组的每一行可以理解为二维数组的一个元素，而二维数组的每一行又是一个一维数组。

二维数组名，也是就是首元素的地址，也就是第一行的地址-一维数组的地址arr。

arr[0][0]是首元素地址 也就是arr 第一行的地址。

数组传参和指针传参

一维数组传参

#include <stdio.h>
void test1(int arr[])test1传的数组首元素地址，而int arr[]本质上是指针 用来存放首元素地址 ok
{

}
void test1(int arr[10])同理
{

}
void test1(int* arr)以指针变量来存放首元素地址 ok
{

}
void test2(int* arr[20])指针数组用来接收实参arr2 指针数组中首元素地址 ok
{

}

void test2(int** arr) 以二级指针来存储指针数组的地址 ok
{

}
int main()
{
	int arr[10] = { 0 };
	int* arr2[20] = { 0 };
	test1(arr);
	test2(arr2);
}

二维数组传参

void test(int arr[3][5])数组int arr[3][5]本质上是数组指针 用来存储首元素地址 ok
{

}
void test(int arr[][])错误 二维数组可以省略行 列不能省略
{

}
void test(int arr[][5])同理 ok
{

}

void test(int *arr)错误 二维数组只能用数组指针接受
{

}
void test(int* arr[5])错误 这是一个指针数组
{

}
void test(int (*arr)[5])正确的 数组指针 用来存放数组的指针 可以通过(*arr)遍历来对应行的元素
{

}
void test(int **arr)错误的 二维数组只能用数组指针接受
{

}
int main()
{
 int arr[3][5] = {0};
 test(arr);
}

一级指针传参

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

p实参其实就是arr 用指针变量当形参接受(没有任何问题)。

函数参数为一级指针时，函数可以接受什么参数呢？

#include <stdio.h>
void test(char* p)
{
	
}
int main()
{
	char arr[] = "abcd";
	char ch = '2';
	char* ptr = &ch;

	test(arr);
	test(&ch);
	test(ptr);
	return 0;
}

二级指针传参

#include <stdio.h>
void test(int** ptr)
{
 printf("num = %d\n", **ptr); 
}
int main()
{
 int n = 10;
 int*p = &n; //一级指针
 int **pp = &p;//二级指针
 test(pp);
 test(&p);
 return 0;
}

?当函数的参数为二级指针时，函数可以接受什么参数呢？

#include <stdio.h>
void test(char** p)
{
	
}
int main()
{
	char* arr[5];
	char ch = 'a';
	char* p = &ch;
	char* pp = &p;
	test(arr);
	test(&p);
	test(pp);
	return 0;
}