4.指针-初阶

1.指针是什么

指针理解的2个要点：

1.指针是内存中一个最小单元的编号，也就是地址

2.平时口语中说的指针，通常指的是指针变量，是用来存放内存地址的变量

总结：指针就是地址，口语中说的指针通常指的是指针变量。

1.1内存是如何管理的

我们将内存切割成内存单元-（一个内存单元为 1byte）

为了方便我们可以找到对应的内存单元，我们可以给每一个内存单元进行编号，把内存单元的编号就称为地址。

地址也叫指针，因此指针就是内存单元的编号。

1.2指针变量

我们可以通过&（取地址操作符）取出变量的内存其实地址，把地址可以存放到一个变量中，这个变量就是指针变量。

#include <stdio.h>
int main()
{
 int a = 10;           // 在内存中开辟一块空间
 int *p = &a;          // 这里我们对变量a，取出它的地址(即第一个内存单元的地址），可以使用&操作符。
                       // a变量占用4个字节的空间，这里是将a的4个字节的第一个字节的地址存放在p变量中，p就是一个之指针量。
 return 0; 
}
    //本质上指针就是地址
	//口语中说的指针，其实是指针变量，指针变量就是一个变量，指针变量是用来存放地址的一个变量

总结：

指针变量，用来存放地址的变量（存放在指针中的值都被当成地址处理），而通过这个地址就可以找到一个内存单元。

1.3如何编址？

对于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个字节。（32bit = 4byte；64bit = 8byte）

• 那如果在64位机器上，如果有64个地址线，那一个指针变量的大小是8个字节，才能存放一个地址。

总结：

• 指针变量是用来存放地址的，地址是唯一标示一块地址空间的。

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

2. 指针和指针类型

这里我们在讨论一下：指针的类型

我们都知道，变量有不同的类型，整形，浮点型等。那指针有没有类型呢？

准确的说：有的。

当有这样的代码：

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

那指针类型的意义是什么？

2.1 指针的解引用

如上图所示：

• pa为指针变量
• *用来说明pa为指针变量
• int* 为pa的类型（即指针变量的类型）
• int 即pa所指向的数据为int类型
• *pa 即解引用pa

通过上面两幅图，我们可以得出结论：

• 指针类型决定了指针在被解引用的时候访问几个字节
• 如果是int*的指针，解引用访问4个字节
• 如果是char*的指针，解引用访问1个字节
• 也可以推广到其他类型（如：short,long , float, double, long long)

2.2指针＋－整数

由上图可得：

• pa与pc中均存放的是a的地址；
• pa+1相对于pa，跳过了4个字节，pa为int*类型
• pc+1相对于pc，跳过了1个字节，pc为char*类型

由此可得出结论：

• 指针的类型决定了指针±1操作的时候，跳过几个字节。（即决定了指针的步长）

3. 野指针

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

3.1 野指针成因

1. 指针未初始化

int main()
{
	int* p;
	// p没有初始化，就意味着没有明确的指向
	// 一个局部变量不初始化的化，放的是随机值

	*p = 10; //非法访问内存了，这里的p就是野指针

	return 0;
}

2. 指针越界访问

int main()
{
	int arr[10] = { 0 };   //数组申请了10个int类型的空间
	int* p = arr;		   // &arr[0]与arr都代表数组首元素的地址
	int i = 0;
	for (i = 0; i <= 10; i++)
	{
		*p = i;
		p++;              //i==10时，访问的空间已经超出了数组申请的空间，此时的p就是野指针
	}

	return 0;
}

3.2 如何规避野指针

1. 指针初始化

2. 当我们不知道给指针赋值什么时，我们可以给指针赋值为空指针；

3. 但是空指针是不可以直接访问的

int* p2 = NULL;  // 初始化指针为空指针

*p2 = 100;       //err（空指针不可以直接访问）

int* p3 = NULL;
if (p3 != NULL)
{
	*p3 = 100;   //ok
}

4. 小心指针越界

5. 指针指向空间释放及时置NULL

6. 避免返回局部变量的地址

当a的地址返回到主函数时，int a 为局部变量，已经销毁了，它占用的内存空间已经还给了操作系统，此时再对其进行访问，则p属于野指针

由上图得：

虽然p已经为野指针，但依旧可以通过存放的地址，对该地址进行非法访问，但由于此地址所属空间已经还给操作系统，因此在我们调用printf时 ，覆盖了野指针p所指向的空间，因此*p的值发生了变化。

6. 指针使用之前，检查其有效性

4. 指针运算

• 指针± 整数

• 指针-指针

• 指针的关系运算

4.1 指针±整数

#include <stdio.h>

#define N_VALUES 5
int values[N_VALUES];
int* vp;               //指针虽然没有初始化，但是也没有解引用使用，也就是没有开始非法访问，所以不算野指针

int main()
{
	int i = 0;
	for (vp = &values[0]; vp < &values[N_VALUES];)
	{
		//指针存放的地址进行比较（也就是内存单元位置的比较；
		//数组存放是从低地址到高地址依次存放
		*vp++ = 1;
		printf("%p\n", vp);
		printf("%d\n", values[i]);
		i++;
	}
    
    // 在C或C++中，解引用操作符 * 和自增操作符 ++ 的优先级是相同的。
    // 解引用操作符 * 和自增操作符 ++ 都是右结合的（right-associative）。这意味着当这两个操作符连续出现时，它们会从右向左进行求值。
    // 注：对于表达式 *vp++，它首先执行 vp++（即先对 vp 进行自增），然后再对自增后的 vp 进行解引用
    // 如果你想要先解引用再自增，你需要使用括号来改变结合性：(*vp)++;

	return 0;
}

4.2 指针-指针

由上图我们可以得出：

• （指针－指针）的绝对值得到的是指针和指针之间元素的个数
• 不是所有的指针都能相减，指向同一块空间的两个指针才可以相减。（不然是没有意义的）

4.2.1 模拟实现strlen（指针-指针的方法）

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


int main()
{
    char arr[] = "abcdef";
    int ret = my_strlen(arr);
    printf("%d", ret);
    return 0;
}

4.3 指针的关系运算

#define N_VALUES 5
float values[N_VALUES];
float *vp;

// &values[N_VALUES] 这个地址越界了
for(vp = &values[N_VALUES]; vp > &values[0];)
{
    // 先执行--，再执行*
    *--vp = 0;
}

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

#define N_VALUES 5
float values[N_VALUES];
float *vp;

// &values[N_VALUES-1] 是数组最后一个元素的地址
for(vp = &values[N_VALUES-1]; vp >= &values[0];vp--) 
{
    *vp = 1;
}

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

标准规定：

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

如上图允许p1与p2进行比较， 但是不允许p1与p3进行比较。

5. 指针和数组

• 数组：一组相同类型元素的集合
• 指针变量：是一个变量，存放的是地址
• 指针和数组的联系：数组名是一个地址，可以用指针变量来存放，继而通过指针变量来访问数组。

由上图可知

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

6.二级指针

int main()
{
	int a = 10;
	int* pa = &a;     // pa是一个指针变量，一级指针变量
	int** ppa = &pa;  // ppa是一个二级指针变量；&pa就是取a变量的地址放入ppa变量   
                      // 其中int*是ppa指向的对象的类型，靠近ppa的*说明ppa是一个指针变量
	
    printf("%p\n", *ppa);
    printf("%d\n", **ppa);
	return 0;
}

总结：

二级指针是用来存放一级指针变量的地址的。

7. 指针数组

• 存放指针的数组就是指针数组

int main()
{
    int a = 10;
	int b = 20;
	int c = 30;

	int* pa = &a;
	int* pb = &b;
	int* pc = &c;
    
    int* parr[10] = {&a, &b, &c};  //[]的优先级高于*；所以parr先和[]结合；所以parr[]是一个数组
    //parr就是存放指针的数组;           int*是数组存放对象的类型；
	//指针数组
    int i = 0;
	for (i = 0; i < 3; i++)//0 1 2
	{
		printf("%d ", *(parr[i])); //parr[i]---->*(parr+i)
	}
}

• 也可以用数组指针来模拟一个二维数组

先来看一组二维数组的打印

int main()
{
   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");
        return 0;
}

模拟的二维数组（利用数组指针）

int main()
{
    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]);//parr[i][j]---->*(parr[i]+j)---->*(*(parr+i)+j)
		}
		printf("\n");
	}

	return 0;
}

附图：