c语言——指针初阶

路漫漫其修远兮，吾将上下而求索。

——屈原《离骚》

1.指针是什么？

一个小的单元到底是多大?内存单元是如何编号的？

2.指针和指针类型

3.什么叫做野指针？野指针的成因和解决办法

4.指针的运算

5.指针和数组

1.指针是什么

理解指针的要点：

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

现在可以这样理解内存：
int a = 10;
a是一个整型变量，整型变量占用4个字节
&a取出的是第一个字节的地址（较小的地址）

指针变量是一种变量，专门用来存放地址的
int* pa = &a //pa就被称为指针变量
a是整型类型，所以pa是整型类型指针

下面列举一个代码：

int main()
{
	int a = 10;
	int* pa = &a;
	printf("%p\n", &a);
	printf("%p\n", pa);//这里 &a和pa等价
	*pa = 20;//* -解引用操作,通过找到a的地址，然后改变a的值
	printf("%d\n", a);//20
	printf("%d\n", *pa);//20

}

一般来说，一个字节对应一个地址是比较合适的
对于32位的机器，假设有32根地址线，那么假设每根地址线在寻址的时候产生高电平（高压电）和低电平（低压电）就产生（1/0）：

看到这里我们大概明白：

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

2.一个小的单元到底是多大?内存单元是如何编号的？

下面举例一个代码

int main()
{
	int a = 0x11223344;
	int* pa = &a;
	*pa = 0;

	char* pc = &a;
	//不管什么指针类型，指针在32位平台中都占用4个字节
	return 0;
}

当进行调试查找a的地址时，a被我赋值为0x11223344
至于为什么是倒着放的，可以搜索 ：大小端。 进行进一步了解

进行下一步操作时

发现a的地址被全部更改成0
当设置一个指针为char类型是，即上图中的黄色箭头指向的代码，

可以发现pa和pc是相等的，存放的都是a的地址，由此可知指针也有自己的内存空间，在32位机器上，大小为4个字节。

再看下面的调试结果：

将指针pc定义为char类型的指针，对该指针解引用后，发现只更改了a地址中的一个字节的值

总结： 指针类型是有意义的 1.指针类型决定了，指针进行解引用操作的时候，一次性访问几个字节
如果是char的指针，解引用访问1个字节
如果是int的指针，解引用访问4个字节
如果是float的指针，解引用访问4个字节
想操作多大类型的空间，就用什么类型的指针（但是指针本身所占用的地址是不变）
不同类型的指针，决定了它的访问权限的大小
指针类型差异决定了访问空间的权限（步长）
*

下面演示char*指针一个一个字节地访问：
所以：

指针的不同类型，其实提供了不同地视角去观看和访问内存 char – 一次访问1个字节，+1向高地址跳过1个字节 int* – 一次访问4个字节，+1向高地址跳过4个字节 同理，-1向低地址跳过多少多少字节*

3. 野指针就是指向的位置是不可知的（随机的，不正确的，没有明确限制的）

野指针成因：
1.指针未初始化。

举例：
int main()
{
	int* p;//p是一个局部变量，未初始化，里边是随机值
	*p = 20;//相当于把p里面的随机值当成一个地址，然后把20放进去
	//未申请空间，不可能进行访问
	//使用指针时，要明确有一个指向
	
	return 0;
}

2.指针越界访问

举例：
int main()
{
	int arr[] = { 1,2,3,4,5,6,7,8,9,10 };
	int* p = arr;
	int i = 0;
	for (i = 0; i <=10; i++)
	{
		printf("%d ", *p);
		p++;
		//p超出了数组的范围，就是野指针
	}
	return 0;
}
//该段代码是错误的，请注意

3.指针指向的空间释放了
（简单举例）

int* test()
{
	int a = 10;
	return &a;
}
int main()
{
	int* p =test();
	//当函数调用结束时，函数栈帧已经销毁，内存空间还给了操作系统
	//此时指针指向了一块没有东西的内存空间
	printf("%d\n", *p);
	//侥幸，别看它已经访问到了，但是不代表代码是对的
	//因为如果函数空间释放之后，没有其他人使用这块空间，那这块空间还保留着之前的
	//东西，就可以侥幸访问到，但是实际上test函数已经销毁
	return 0;
}

但是当在test函数用过了的空间中赋给一些其他东西，打印出来的a就不再是5

如何规避野指针

1.指针初始化
2.小心指针越界
3.指针指向的空间释放后，及时把指针置于空指针（NULL）
4.避免返回局部变量的地址
5.指针使用之前检查有效性

初始化，检查有效性
int main()
{
	//int a = 10;
	//int* pa = &a;

	//或者
	int* p = NULL;//--空指针，专门用来初始化指针
	//不能使用初始化的空值

	if (p != NULL)
	{
		*p = 20;
	}
	return 0;
}

4.指针运算

4.1.指针±整数
一个指针±整数后，结果仍然是指针

#define M 5
float values[M];
float* vp;
for (vp = &values[0]; vp < &values[5];)
{
	*vp++ = 0;
	//*vp = 0；
	//vp = vp+1;
}

4.2.指针-指针
前提：两个指针要指向同一块空间，且两个指针的类型相同
指针-指针的绝对值，得到的是两个指针之间的元素个数

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

}

再举个例子：
自己写一个函数求一个字符串的长度
1.计数器
2.递归

求字符串长度，其实是在统计\0之前出现的字符的个数：

计数器
int my_strlen(char* str)
{
	int count = 0;
	while (*str != '\0')
	{
		count++;
		str++;
	}
	return count;
}
int main()
{
	char arr[] = "abcdef";
	int len=my_strlen(arr);
	printf("%d\n", len);
}

指针-指针方法
计算的是两个指针之间的元素个数

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

int main()
{
	char arr[] = "abcdef";
	int len = my_strlen(arr);
	printf("%d\n", len);
}

4.3指针的关系运算
举个例子：

#define M 5
for (vp = &values[M]; vp > values[0];)
{
	*--vp = 0;
	//先--，再*vp =0
}

这里都能够将values地址中的值修改为0

有人将这段代码简化如下：
for (vp = &values[M]; vp > values[0];vp--)
{
	*vp = 0;
}

实际上在绝大部分的编译器上是可以顺利完成任务的，然而标准不一定允许它这样；

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

也就是说，指针可以进往后越界，但是不能向前越界，所谓的越界，只是指针指向了数组之外的空间，但是并没有访问（可以这样想：我来到你家门口，但是我没有敲门去打扰你）

5.指针和数组

1.指针和数组是不同的对象 指针是一种变量，存放地址的，大小是4/8字节的 数组是一组相同类型元素的集合，是可以放多个元素的，大小取决于元素个数和元素类型的
2.数组的数组名是数组首元素的地址，地址可以放在指针变量中， 可以通过指针访问数组

int main()
{
	
	int arr[10] = { 0 };
	int* p =arr;
	int i = 0;
	int sz = sizeof(arr) / sizeof(arr[0]);
	//初始化
	for (i = 0; i < sz; i++)
	{
		//*p++ = i + 1;//先解引用，再++
		//或者
		*(p + i) = i + 1;//好处是p没动，没变过
	}
	//打印
	//p = arr;
	for (i = 0; i < sz; i++)
	{
		//printf("%d ", *p++);
		//printf("%d ", *(p+i));
		//printf("%d ", *(i + p));
		//printf("%d ", arr[i]);
		printf("%d ", i[arr]);
		//原因：[]是个操作符，i和arr是[]这个操作符的操作数而已
		//并且arr是首元素的地址，相当于a+b==b+a
		//不过一般不这么写，只是方便理解


	}
	return 0;
}

总结：指针是一个很有趣的东西，很灵活，学好指针，非常有必要，今天先讲到这里，后续学到更详细的内容会进行补充

下课！