学C的第十七天【指针初阶：指针是什么、指针和指针类型、野指针、指针运算】

=========================================================================

相关代码gitee自取：C语言学习日记: 加油努力 (gitee.com)

=========================================================================

接上期： 
学C的第十六天【续操作符详解、练习】_高高的胖子的博客-CSDN博客

========================================================================= 

                     

 1. 指针是什么？

                               

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

                            

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

                     

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

                             

                                     

---

                                

1.1 * 指针变量

                           

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

                     

#include <stdio.h>
int main()
{
	int a = 100; //在内存中开辟一块空间

	int* pa = &a; //取出变量a的地址，使用&（取地址操作符）
	//a变量占用4个字节的空间，这里是将a的4个字节的第一个字节的地址
	//放在pa变量中，pa就是一个指针变量
	// pa 是专门用来存放地址（指针）的，
	// int * 可以分开理解
	// * 告诉我们 pa 是 指针
	// int 告诉我们 pa 指向的 a 是 int类型

	printf("%p", pa);

	return 0;
}

                

总结：

           

指针变量，用来存放地址的变量。（存放在指针中的值都被当成地址处理）
                 

---

                                 

1.2 * 内存单元的编址

            

查看往期文章：

学C的第五天（初识指针，内存产生内存单元地址过程，指针函数介绍和其大小；结构体补充）_高高的胖子的博客-CSDN博客

                      

总结：

                        

（1）. 在32位机器上，地址是32个0或1组成的二进制序列，那地址就得用4个字节的空间来存储，所以一个指针变量的大小就应是4个字节。

        

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

        

（3）. 指针变量是用来存放地址的，地址是唯一标示一个内存单元的。

        

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

                           

---

                                  

2. 指针和指针类型

                     

指针的定义方式：

             

type + * 

              

(如：int类型 -- int * 变量)

               

不同 类型* 的指针是为了存放 该类型类型变量 的地址。

（如：char* 类型 的指针是为了存放 char类型变量 的地址）

                       

---

                  

 2.1 * 指针类型的意义（不同指针类型访问的对象的大小）

               

int* 类型 的指针变量：

//指针类型的意义
#include <stdio.h>
int main()
{
	int a = 0x11223344; //0x开头的是16进制数字
	int* pa = &a;
	*pa = 0;

	return 0;
}

              

char* 类型 的指针变量：

//指针类型的意义：char*
#include <stdio.h>
int main()
{
	int a = 0x11223344; //0x开头的是16进制数字
	char* pa = &a;
	*pa = 0;

	return 0;
}

               

               

总结：

                             

对于指针变量：        type        *        p;

                 

（1）.   *  ：说明 p 是指针变量

               

（2）. type：说明 p 指向的对象类型

               

（3）. type：p 解引用的时候访问的对象的大小是 sizeof(type) --> 重点！

                      

（4）. 指针的类型决定了指针解引用时有多大的权限（能操作几个字节）

                        

---

                  

 2.2 * 指针类型的意义（指针 +- 整数）

             

//指针类型的意义2：
#include <stdio.h>
int main()
{
	int a = 0x11223344; //0x开头的是16进制数字

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

                         

总结：

                

指针的类型决定了指针向前或者向后走一步有多大（步长）。

                     

---

                            

3. 野指针

                   

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

                 

---

                       

3.1 * 野指针成因

                

1. 指针未初始化

                

               

2. 指针越界访问

                       

                    

3. 指针指向的空间释放

            

---

                    

3.2 * 如何规避野指针

                  

1. 指针初始化

                

（1）. 明确知道这种应该初始化为谁的地址，就直接初始化

                 

（2）. 不知道这种初始化为何值时，暂时初始化为NULL（空指针），没有指向任何有效的空间，该指针不能直接使用

                

             

2. 小心指针越界

              

3. 指针指向的空间释放，及时将它置为NULL（空指针）

               

4. 避免返回局部变量的指针

                  

5. 指针使用之前检查有效性

               

                   

---

                     

4. 指针运算

              

• 指针        +-        整数

          

• 指针        -        指针

            

• 指针的关系运算

              

---

               

4.1 * 指针        +-        整数

//指针运算
#include <stdio.h>
int main()
{
	int arr[10] = { 0 };
	//不使用下标访问数组
	int* p = &arr[0]; //相当于arr
	int i = 0;
	int sz = sizeof(arr) / sizeof(arr[0]); //数组长度

	//使用指针运算循环赋值：
	//第一种方法：
	for (i = 0; i < sz; i++)
	{
		*p = i;
		p++; //指针运算
		// p = p + 1; 指针加一，移到数组中的下一位
	}
	
	//第二种方法：
	//for (i = 0; i < sz; i++)
	//{
	//	*(p + i) = i; 
	//}

	//使用指针打印
	p = arr; //地址位置还原到数组第一个元素位置进行打印
	for (i = 0; i < sz; i++)
	{
		printf("%d ", *(p + i));
	}

	return 0;
}

             

补充：

                  

                    

4.2 * 指针        -        指针

//地址-地址（指针-指针）
#include <stdio.h>
int main()
{
	int arr[10] = { 0 };
	printf("%d\n", &arr[9] - &arr[0]);
	printf("%d\n", &arr[0] - &arr[9]);

	// 指针-指针 得到的数值的绝对值：是指针和指针之间的元素个数
	
	// 指针-指针 运算的前提条件：指针和指针指向了同一块空间（同一数组）

	return 0;
}

                   

               

应用：使用 指针 - 指针 求字符串长度

//应用：
#include <stdio.h>

//第一种版本：正常思路
//int my_strlen(char* s)
//{
//	int count = 0; //统计字符串个数
//	if (*s != '\0')//数组首元素不是结束标志
//	{
//		count++; //能进来说明有元素，个数++
//		s++; //判断下一位
//	}
//	return count;
//}

//第二种版本：递归
//int my_strlen(char* s)
//{
//	if (*s == '\0')
//	{
//		return 0;
//	}
//	else
//	{
//		return 1 + my_strlen(s + 1);
//	}
//}

//第三种版本：指针减指针求数组元素个数
int my_strlen(char* s)
{
	char* start = s;
	while (*s != '\0') //也可以写成 while(*s) ,\0的ASCII码值是0
	{
		s++;
	} //循环到找到 \0 的地址
	return s - start; //指针-指针：\0地址 - 首地址 = 元素个数
}


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

	return 0;
}

             

           

4.3 * 指针的关系运算

//指针的关系运算（比较大小）
#include <stdio.h>

#define N_VALUES 5 //定义宏：数组长度为5

int main()
{
	float values[N_VALUES]; //浮点数数组
	float* vp;

	for (vp = &values[N_VALUES]; vp > &values[0];)
	// vp 等于 数组第五个元素的地址；vp 大于 数组第0个元素的地址
	{
		*--vp = 0; // vp先 -- ，再解引用 vp，把第四个元素赋值为0，然后是第三个、第二个……
	}
	//实现倒着给数组赋值

	int i = 0;
	for (i = 0; i < N_VALUES; i++)
	{
		printf("%d ", *(vp + i));
	}

	return 0;
}

               

标准规定：

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