指针的初阶

1. 指针是什么？

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

 那这里的问题是：
一个小的单元到底是多大？（1个字节）
如何编址？
经过仔细的计算和权衡我们发现一个字节给一个对应的地址是比较合适的。
对于32位的机器，假设有32根地址线，那么假设每根地址线在寻址的时候产生高电平（高电压）和低电
平（低电压）就是（1或者0）；
那么32根地址线产生的地址就会是：

00000000 00000000 00000000 00000000
00000000 00000000 00000000 00000001
...
11111111  11111111   11111111   11111111
 
这里就有2的32次方个地址。
每个地址标识一个字节，那我们就可以给

（2^32Byte == 2^32/1024KB == 2^32/1024/1024MB==2^32/1024/1024/1024GB == 4GB）

4G的空闲进行编址。
同样的方法，那64位机器，如果给64根地址线，那能编址多大空间，自己计算。
这里我们就明白：
在32位的机器上，地址是32个0或者1组成二进制序列，那地址就得用4个字节的空间来存储，所以
一个指针变量的大小就应该是4个字节。
那如果在64位机器上，如果有64个地址线，那一个指针变量的大小是8个字节，才能存放一个地
址。

 

---

2. 指针和指针类型 

NULL=（（void*）0） 

//X86 - 32位的环境
//X64 - 64位的环境

//int main()
//{
//	char* pc = NULL;
//	short* ps = NULL;
//	int* pi = NULL;
//	double* pd = NULL;
//
//	//ptr_t pt = NULL;
//
//	//sizeof 返回的值的类型是无符号整型  unsigned int
//	printf("%zu\n", sizeof(pc));
//	printf("%zu\n", sizeof(ps));
//	printf("%zu\n", sizeof(pi));
//	printf("%zu\n", sizeof(pd));
//
//	return 0;
//}

指针的大小在32位平台是4个字节，在64位平台是8个字节。

一个16进制数代表着4个2进制数

---

//int main()
//{
//	int a = 0x11223344;
//	int*  pa = &a;
//	char* pc = (char*)&a;
//
//	printf("pa = %p\n", pa);
//	printf("pa+1 = %p\n", pa+1);
//
//	printf("pc = %p\n", pc);
//	printf("pc+1 = %p\n", pc+1);
//
//	//结论2：
//	//指针的类型决定了指针+-1操作的时候，跳过几个字节
//	//决定了指针的步长
//
//	//100 - 10进制
//	//0x64 - 16进制
//	//110 0100 - 2进制
//	//144 - 8进制
//	return 0;
//}

---

---

 存储类型与指针访问类型没有关系，就像门牌上写的是四人间但不一定只能住四个人，也可以住八个人。

---

3. 野指针

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

3.1 野指针成因 

1. 指针未初始化

//int main()
//{
//	int* p;
//	//p没有初始化，就意味着没有明确的指向
//	//一个局部变量不初始化的化，放的是随机值：0xcccccccc
//	//
//	*p = 10;//非法访问内存了，这里的p就是野指针
//
//	return 0;
//}

 2. 指针越界访问

3. 指针指向的空间释放 

 

 局部变量使用完成后就会销毁，所以说*p只获得了a的地址，但地址里存的东西已经被销毁了。

---

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

//int main()
//{
//	//int b = 0;
//	//int a = 10;
//	//int* p = &a;
//	//*p = 20;
//	//NULL -> 0
//
//	//int* p2 = NULL;
//	//*p2 = 100;//err
//
//	int* p3 = NULL;
//
//	if (p3 != NULL)
//	{
//		*p3 = 100;//ok
//	}
//
//	return 0;
//}

*p=NULL ，0指针无法访问所以一般以这何种形式进行存储：

if (p3 != NULL)

{
    *p3 = 100;

}

---

4. 指针运算

4.1 指针+-整数 

//int main()
//{
//	int arr[10] = {0};
//	int i = 0;
//	int sz = sizeof(arr) / sizeof(arr[0]);
//	//数组下标的写法
//	//for (i = 0; i < sz; i++)
//	//{
//	//	arr[i] = 1;
//	//}
//
//	/*int* p = arr;
//	for (i = 0; i < sz; i++)
//	{
//		*p = 1;
//		p++;
//	}*/
//
//	//int* p = arr;
//	//for (i = 0; i < sz; i++)
//	//{
//	//	*(p + i) = 1;
//	//}
//
//	return 0;
//}

4.2 指针-指针

//int main()
//{
//	//int arr[10] = { 0 };
//	//printf("%d\n", &arr[0] - &arr[9]);//?
//	// 
//	// 
//	//int arr[10] = { 0 };
//	//char ch[5] = {0};
//	//printf("%d\n", &ch[0] - &arr[5]);//err
//
//
//	return 0;
//}

指针减指针使用方法

#include <string.h>

//1
//int my_strlen(char* str)
//{
//	int count = 0;
//	while (*str != '\0')
//	{
//		count++;
//		str++;
//	}
//
//	return count;
//}
//2. 递归的版本

//3. 指针-指针
//int my_strlen(char* str)
//{
//	char* start = str;
//	while (*str != '\0')
//	{
//		str++;
//	}
//	return (str - start;
//}
//
//int main()
//{
//	int len = my_strlen("abcdef");
//	printf("%d\n", len);
//
//	return 0;
//}

 指针加指针无意义

4.3 指针的关系运算 

实际在绝大部分的编译器上是可以顺利完成任务的，然而我们还是应该避免这样写，因为标准并不保证它可行。
标准规定：
允许指向数组元素的指针与指向数组最后一个元素后面的那个内存位置的指针比较，但是不允许与指向第一个元素之前的那个内存位置的指针进行比较。

---

5. 指针和数组 

//数组：一组相同类型元素的集合
//指针变量：是一个变量，存放的是地址

//int main()
//{
//	int arr[10] = {0};
//	//arr 是首元素的地址
//	//&arr[0]
//	int* p = arr;
//	//通过指针来访问数组
//	int sz = sizeof(arr) / sizeof(arr[0]);
//	int i = 0;
//
//	for (i = 0; i < sz; i++)
//	{
//		printf("%p ----- %p\n", &arr[i], p + i);
//	}
//
//	//for (i = 0; i < sz; i++)
//	//{
//	//	printf("%d ", *(p + i));
//	//}
//
//	return 0;
//}


//void test(int* p, int sz)
//{
//	int i = 0;
//	for (i = 0; i < sz; i++)
//	{
//		printf("%d ", *(p + i));
//	}
//}

//void test(int arr[], int sz)
//{
//	int i = 0;
//	for (i = 0; i < sz; i++)
//	{
//		printf("%d ", arr[i]);//arr[i]--> *(arr+i)
//	}
//}
//
//int main()
//{
//	int arr[10] = {0};
//	test(arr, 10);
//
//	return 0;
//}

---

6.二级指针

 

存放指针的数组叫做指针数组 

---

7. 指针数组

//int main()
//{
//	//int a = 10;
//	//int b = 20;
//	//int c = 30;
//
//	//int arr[10];
//
//	//int* pa = &a;
//	//int* pb = &b;
//	//int* pc = &c;
//
//	parr就是存放指针的数组
//	指针数组
//	//int* parr[10] = {&a, &b, &c};
//
//	//int i = 0;
//	//for (i = 0; i < 3; i++)//0 1 2
//	//{
//	//	printf("%d ", *(parr[i]));
//	//}

指针数组的用法

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

   int arr[3][4] = { 1,2,3,4,2,3,4,5,3,4,5,6 };

   与

   int arr1[4] = { 1,2,3,4 };

   int arr2[4] = { 2,3,4,5 };

   int arr3[4] = { 3,4,5,6 };

   int* parr[3] = {arr1, arr2, arr3};
输出效果等同