【初阶】C语言之指针

---

一、指针是什么？

在计算机科学中，指针（Pointer）是编程语言中的一个对象，利用地址，它的值直接指向存在电脑存储器中另一个地方的值。

由于通过地址能找到所需的变量单元，可以说，地址指向该变量单元。
因此，将地址形象化的称为“指针”。意思是通过它能找到以它为地址的内存单元。

1. 内存

内存是电脑上特别重要的存储器，计算机中程序的运行都是在内存中进行的 。
为了有效的使用内存，把内存划分成一个个小的内存单元，每个内存单元的大小是1个字节。
为了能够有效的访问到内存的每个单元，就给内存单元进行了编号，这些编号被称为该内存单元的地址。

2. 指针

指针是个变量，存放内存单元的地址。（存放在指针中的值都被当成地址处理）。

#include <stdio.h>
int main()
{
    int num = 10;//在内存中开辟一块空间
    int *p = &num;//这里我们对变量num，取出它的地址，可以使用&操作符。
    //将num的地址存放在p变量中，p是用来存放地址的，p是一个指针变量。
    return 0;
}

分配的地址释放后再分配不一定与原地址相同。

3. 指针变量的大小

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

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

💡一个小的单元到底是多大？（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根地址线，就有8G的间进行编址。

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

✨总结✨

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

二、指针和指针类型

💡我们都知道，变量有不同的类型，整形，浮点型等。那指针有没有类型呢？
当有这样的代码：

int num = 10;
p = #

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

char *pc = NULL;
int *pi = NULL;
short *ps = NULL;
long *pl = NULL;
float *pf = NULL;
double *pd = NULL;

这里可以看到，指针的定义方式是： type + * 。
其实：

char* 类型的指针是为了存放 char 类型变量的地址。
short* 类型的指针是为了存放 short 类型变量的地址。
int* 类型的指针是为了存放 int 类型变量的地址。

1. 指针类型的意义

1.1 在指针解引用中的意义

💡比较两段代码的差异：

#include <stdio.h>
int main()
{
	int a = 0x11223344;
	int *pa = &a;
	*pa = 0;
	printf("%d\n", *pa);
	return 0;
}

#include <stdio.h>
int main()
{
	int a = 0x11223344;
	char *pc = &a;//int*和char*内存大小都为4个字节，可以存放
	*pc = 0;
	return 0;
}

✨结论✨
指针类型决定了指针解引用操作时，一次访问几个字节（访问内存的大小）。
char* 指针解引用访问 1 个字节
int* 指针解引用访问 4 个字节

1.2 在指针±整数中的意义

#include <stdio.h>
int main()
{
	int a = 10;
	int* pa = &a;
	char* pc = &a;

	printf("%p\n", pa);
	printf("%p\n", pc);

	printf("%p\n", pa + 1);
	printf("%p\n", pc + 1);

	return 0;
}

运行结果：

012FF924
012FF924 
012FF928  //int* 指针+1跳过4个字节
012FF925  //char* 指针+1跳过1个字节

✨结论✨

指针类型决定了指针±整数的时候的步长。

🌸 练习

#include <stdio.h>
int main()
{
	int arr[10] = { 0 };

	char* pa = arr;
	int i = 0;
	for (i = 0; i < 40; i++)
	{
		*(pa + i) = 1;
	}
	return 0;
}

#include <stdio.h>
int main()
{
	int arr[10] = { 0 };

	int* pc = arr;
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		*(pc + i) = 1;
	}
	return 0;
}

三、野指针

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

1. 野指针成因

1.1 指针未初始化

//错误代码
#include <stdio.h>
int main()
{
    int *p;//局部变量指针未初始化，默认为随机值
    *p = 20;
    //通过p中存在的随机值的地址，找到一个空间，这个空间不属于我们当前的程序
    //造成了非法访问，p是野指针。
    return 0;
}

1.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;
}

超出数组部分的地址，我们可以指向这块地址，记录这块地址的位置，但不可以访问。

1.3 指针指向的空间释放

💡对比下面两段代码：

//错误代码
#include<stdio.h>
int* test()
{
	int a = 10;
	return &a;
}

int main()
{
	int* p = test();
	printf("%d\n", *p);

	return 0;
}

#include<stdio.h>
int* test()
{
	int a = 10;
	return &a;
}

int main()
{
	int* p = test();

	printf("hehe\n");

	printf("%d\n", *p);

	return 0;
}

a为局部变量，一旦出了作用域，其空间就被释放，还给操作系统。
释放后，若其空间未被再次覆盖，此时重新访问，得到的值和原来一样。

🌸 观察下面代码运行结果：

#include<stdio.h>
int main()
{
	int a = 10;
	int b = 20;
	
	printf("%p\n", &a);
	printf("%p\n", &b);


	return 0;
}

✨结论✨
栈：先使用高地址，再使用低地址

2. 如何规避野指针

2.1 指针初始化

int a = 10;
int* p = &a;//明确地初始化，确定指向
int* p2 = NULL;//不知道一个指针当前应该指向哪里时，可以初始化为NULL

2.2 小心指针越界

2.3 指针指向空间释放后立即置NULL

2.4 避免返回局部变量的地址

局部变量出了作用域，其空间立即被释放。

2.5 指针使用之前检查有效性

int* p2 = NULL;//不知道一个指针当前应该指向哪里时，可以初始化为NULL
*p2 = 100;//err

空指针不能直接进行解引用！

故使用需要检验其有效性:👇👇👇

int* p2 = NULL;

	if (p2 != NULL)
	{
		*p2 = 100;
	}

四、指针运算

1. 指针±整数

#define N_VALUES 5
float values[N_VALUES];
float *vp;
//指针+-整数；指针的关系运算
for (vp = &values[0]; vp < &values[N_VALUES];)
{
    *vp++ = 0;
}

关于宏的讲解请点击这里👉C语言入门

🌸 练习

#include<stdio.h>
int main()
{
	int arr[10] = { 1,2,3,4,5,6,7,8,9,0 };
	int* p = &arr[9];

	printf("%p\n", p);
	printf("%p\n", p - 2);
	return 0;
}

2. 指针-指针

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

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

	printf("%d\n", &arr[9] - &arr[0]);
	printf("%d\n", &arr[0] - &arr[9]);

	return 0;
}

✨结论✨
指针-指针 的前提是两个指针指向同一块区域
指针-指针 得到的数字的绝对值是指针和指针之间元素的个数

🌸 练习：用函数my_strlen实现库函数strlen的功能

#include<stdio.h>
#include <string.h>
int my_strlen(char* s)
{
	int count = 0;
	while (*s != '\0')
	{
		count++;
		s++;
	}
	return count;
}

//int my_strlen(char* s) //求两字符中间字符串的长度
//{
//	int count = 0;
//	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;
}

strlen 和 sizeof 的区别请点击这里：操作符解析

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;
}

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

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

五、指针和数组

#include<stdio.h>
int main()
{
	int arr[10] = { 0 };
	printf("%p\n", arr);//数组名是首元素的地址
	printf("%p\n", arr+1);

	printf("%p\n", &arr[0]);//第一个元素的地址
	printf("%p\n", &arr[0]+1);

	printf("%p\n", &arr);//取出整个数组的地址
	printf("%p\n", &arr + 1);

	return 0;
}

✨结论✨
数组名表示的是数组首元素的地址
数组名、数组首元素的地址和整个数组的地址是一样的。

#include<stdio.h>
int main()
{
	int arr[10] = { 0 };
	int* p = &arr[5];
	int* q = arr;

	int sz = sizeof(arr);
	printf("%d\n", sz);

	printf("%p\n", arr);
	printf("%p\n", &arr[0]);
	return 0;
}

✨补充✨
数组名确实是首元素的地址
但是有2个例外：
1.sizeof(数组名) – 这里的数组名不是首元素的地址，是表示整个数组的地址，这里计算的是整个数组的大小，单位还是字节。
2. &数组名 – 这里的数组名不是首元素的地址，是表示整个数组的地址，拿到的是整个数组的地址。

1. 练习

#include <stdio.h>
int main()
{
    int i = 0;
    int arr[] = { 1,2,3,4,5,6,7,8,9,0 };
    int* p = arr; //指针存放数组首元素的地址
    int sz = sizeof(arr) / sizeof(arr[0]);
    for (i = 0; i < sz; i++)
    {
        printf("&arr[%d] = %p   <====> p+%d = %p\n", i, &arr[i], i, p + i);
    }
    return 0;
}

所以 p+i 其实计算的是数组 arr 下标为 i 的地址。
那我们就可以直接通过指针来访问数组。
如下：

#include <stdio.h>
int main()
{
    int arr[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 0 };
    int* p = arr; //指针存放数组首元素的地址
    int sz = sizeof(arr) / sizeof(arr[0]);
    int i = 0;
    for (i = 0; i < sz; i++)
    {
        printf("%d ", *(p + i));
    }
    return 0;
}
//1 2 3 4 5 6 7 8 9 0

六、二级指针

指针变量也是变量，是变量就有地址，那指针变量的地址存放在哪里？
这就是二级指针 。

int* *ppa=&a 的含义：
*ppa表示 ppa 是一个指针变量。
int *表示 ppa 所指向的 pa 是 int * 类型的。

1. 二级指针的运算

*ppa 通过对 ppa 中的地址进行解引用，这样找到的是 pa ， *ppa 其实访问的就是 pa 。

int a = 10;
*ppa = &a;//等价于 pa = &a;

**ppa 先通过 *ppa 找到 pa ,然后对 pa 进行解引用操作： *pa ，那找到的是 a 。

**ppa = 30;
//等价于*pa = 30;
//等价于a = 30;

七、指针数组

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

数组我们已经知道整型数组、字符数组：

int arr1[5];
char arr2[6];

那指针数组是怎样的？

int* arr3[5];
//arr3是一个数组，有五个元素，每个元素是一个整型指针。

🌸 练习：

#include <stdio.h>
int main()
{
	int a = 10;
	int b = 20;
	int c = 30;

	int* arr[3] = {&a, &b, &c};

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

	return 0;
}

✨运行结果✨

10
20
30

---

如有问题，欢迎批评指正呀！