C语言_初阶_指针

本章重点

1. 指针是什么
2. 指针和指针类型
3. 野指针
4. 指针运算
5. 指针和数组
6. 二级指针
7. 指针数组

1.指针是什么？

在计算机科学中，指针（Pointer）是编程语言中的一个对象，利用地址，它的值直接指向（points to）存在电脑存储器中另一个地方的值。由于通过地址能找到所需的变量单元，可以说，地址指向该变量单元。因此，将地址形象化的称为“指针”。意思是通过它能找到以它为地址的内存单元。

那我们就可以这样理解:

1.1内存

这里可以简单理解为：编号=地址=指针

1.2指针

指针是个变量，存放内存单元的地址（编号）。

int main()
{
	int a = 10; /在内存中开辟一块空间
	int * pa = &a; /这里我们对变量a，取出它的地址，可以使用&操作符
	/将a的地址存放在pa变量中，pa就是一个指针变量
	return 0;
}

总结：指针就是变量，用来存放地址的变量。（存放在指针中的值都被当成地址处理)

注意：

• 一个小的单元到底是多大？（1个字节）
• 指针是用来存放地址的，地址是唯一标示一块地址空间的。
• 指针的大小在32位平台是4个字节，在64位平台是8个字节。

解析：

32根地址线产生的地址是：

00000000 00000000 00000000 00000000
00000000 00000000 00000000 00000001
…
11111111 11111111 11111111 11111111

根据上图我们可看出：

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

2.指针和指针类型

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

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 类型变量的地址。

补充：
如果要用sizeof计算指针变量的大小，（指针大小不论类型，地址大小是固定的）计算的大小自然是根据32/64，也就是4/8个字节大小。
那指针类型的意义是什么？

• 指针类型决定了：指针解引用的权限有多大
• 指针类型决定了：指针走一步能走多远（步长）
• 整型指针（int)+4；字符指针(char)+1；double型+8；

指针±整数

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

指针的解引用

注意：这里的地址顺序为倒序，先取出n的地址如上图
注意：通过解引用访问改变这块空间的值

那么我们换个指针变量类型会产生什么结果呢？

用解引用访问改变这块空间地址后变为：

补充：
总结： 指针的类型决定了，对指针解引用的时候有多大的权限（能操作几个字节）。 比如： char* 的指针解引用就只能访问一个字节，而 int* 的指针的解引用就能访问四个字节。

3.野指针

概念： 野指针就是指针指向的位置是不可知的（随机的、不正确的、没有明确限制的）
指针变量在定义时如果未初始化，其值是随机的，指针变量的值是别的变量的地址，意味着指针指向了一个地址是不确定的变量，此时去解引用就是去访问了一个不确定的地址，所以结果是不可知的

3.1野指针成因

1. 指针未初始化

int main()
{
	int* p; //p是一个局部的指针变量，局部变量不初始化的话，默认是随机值
	*p = 20;//非法访问内存了
	return 0;
}

局部变量不初始化的话，默认是随机值

2. 指针越界访问

int main()
{
	int arr[10] = { 0 };
	int* p = arr;
	int i = 0;
	for (i = 0; i <= 10; i++)
	{
		//当指针指向的范围超出数组arr的范围时，p就是野指针
		*p = i;
		p++;
	}
	return 0;
}

注意：i指的是下标 ；i<=10的话就会访问第11个的地址，那么就超出了数组（10个元素的范围），所以就是野指针。

3. 指针指向的空间释放

int* test()
{
	int a = 10;
	return &a;
}
int main()
{
	int* p = test();
	*p = 20;
	return 0;
}

注意：这里上面的 test函数里面创建的a变量在出这个函数后就会销毁，还给了操作系统，&a返回的地址a给到下面的int p;但是后面再用p去访问（也就是将上面的10赋为20）时就为非法访问了

3.2如何规避野指针

1. 指针初始化

• 当前不知道p应该初始化为什么地址的时候，直接初始化为NULL（也就是空指针）

int main()
{
	int* p = NULL;//(NULL相当于0）
	return 0;
}

• 明确知道初始化的值

int main()
{
    int a = 10;
    int *pa = &a;
    return 0;
}

2. 小心指针越界（C语言本身是不会检查数据的越界行为的）
3. 指针指向空间释放及时置NULL（置空）
4. 指针使用之前检查有效性

int main()
{
	int* p = NULL;//(NULL相当于0）
	if (p != NULL)
	{
		*p = 20;
	}
	return 0;
}

如果前面定义为空指针，那么后面你要去解引用时是无效的，只有在它不是NULL时才能去解引用访问它的地址

4.指针运算

• 指针± 整数
• 指针-指针
• 指针的关系运算

4.1指针±整数

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

画图解释：
注意：地址是由低到高运算的！！！

用这个灵活写代码为：

4.2指针-指针

问题：为什么这里的结果为9呢？

解析：指针-指针得到的是两个指针之间的个数
注意这里的个数要包括最开始的；
例如：上题从&arr[0]到&arr[9]，一共有 9 个元素（索引 0 到索引 8）

虽然这里能够产生值，但是是错误的，程序也会报错！

注意：指针和指针相减的前提为两个指针指向同一块空间

4.3指针的关系运算

for(vp = &values[N_VALUES]; vp > &values[0];)
{
    *--vp = 0;
}

代码简化, 这将代码修改如下：

for(vp = &values[N_VALUES-1]; vp >= &values[0];vp--)
{
    *vp = 0;
}

注意：实际在绝大部分的编译器上是可以顺利完成任务的，然而我们还是应该避免这样写，因为标准并不保证它可行。
标准规定：

允许指向数组元素的指针与指向数组最后一个元素后面（方框5之后）的那个内存位置的指针比较，但是不允许与指向第一个元素之前(黄色方框）的那个内存位置的指针进行比较。

5指针和数组

数组名是什么？我们看一个例子：

int main()
{
 int arr[10] = {1,2,3,4,5,6,7,8,9,0};
    printf("%p\n", arr);
    printf("%p\n", &arr[0]);
    return 0;
}

可见数组名和数组首元素的地址是一样的。
**结论：**数组名表示的是数组首元素的地址。

但是有两个例外：

• sizeof(数组名)
• &数组名

这里的数组名代表的是整个数组。

那么这样写代码是可行的：

int arr[10] = {1,2,3,4,5,6,7,8,9,0};
int *p = arr;//p存放的是数组首元素的地址
我们知道了数组首元素的地址，就可以遍历出其他元素的地址

既然可以把数组名当成地址存放到一个指针中，我们使用指针来访问一个就成为可能。
所以p+i 其实计算的是数组 arr 下标为i的地址。

那我们就可以直接通过指针来访问数组:注意：这里就可以通过p+i遍历出整个数组，*（p+i)来访问下标为i的元素）

6.二级指针

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

对于二级指针的运算有：

• *ppa 通过对ppa中的地址进行解引用，这样找到的是 pa ，*ppa其实访问的就是 pa
• **ppa 先通过 *ppa 找到 pa ,然后对pa进行解引用操作：*pa，那找到的是a

7.指针数组

指针数组是指针还是数组？
答案：是数组。是存放指针的数组。