指针的知识

深碍√TFBOYSˉ_ 2024-03-26 21:34 18阅读 0赞

这两天发现我指针的掌握能力很差，故在B站找一位UP主“鹏哥C语言”学习了一下，这次就不跟翁恺老师了，不说了，（注意：我把代码写出来，都可以直接润，我用注释对代码做出了解释）内容如下：

## 目录 ##

（一）初识指针

1.初识指针：

2.\*解引用操作符

3.测试各种数据类型指针的byte长度

4.各指针类型的区别，如char和int型指针：

5.二进制转十六进制

6.野指针

（二）指针进阶

1.指针与数组的差别

2.字符串数组和字符串指针的区别

--------------------

## （一）初识指针 ##

前言：

1.32位操作系统使用32根地址线（这里的地址线是指物理线）通过通电与否来实现1/0的转换，即将电信号转换成数字信息:1和0组成的二进制序列

2.一个内存单元是一个字节的大小

### 1.初识指针： ###

#include <stdio.h>
    
    
    //指针就是地址
    
    // 指针的大小跟地址线的多少有关，地址线又与32位或64位操作系统有关
    
     int main()
     {
         // a在内存中要分配空间-4个字节
         int a = 10;     
         // pa用来存放地址，在c语言中pa叫指针变量
         int* pa = &a;
         //      return 0;
     }		//* 说明pa是指针变量
    		//int 说明pa执行对象是int类型的

### 2.\*解引用操作符 ###

int main()
     {
         int a = 10;
         int* pa = &a;
    
         *pa = 20;   // * 解引用操作符，* pa是通过pa里面的地址找到a
    
         return 0;
     }

### 3.测试各种数据类型指针的byte长度 ###

int main()
    {
        printf("%d\n", sizeof(char*));
        
        printf("%d\n", sizeof(int*));
        
        printf("%d\n", sizeof(long long*));
        
        printf("%d\n", sizeof(long*));
        
        printf("%d\n", sizeof(short*));
        
        printf("%d\n", sizeof(double*));
        
        printf("%d\n", sizeof(float*));
    }

run之后你会发现：我们用32位的时候，指针的字节长度都是4个字节，调为64位的时候，指针字节长度都为8个字节。

原因：32位操作系统：32 / 8（1byte = 8 bite）= 4 byte

64位的同理64/ 8（1byte = 8 bite）= 8 byte

### 4.各指针类型的区别，如char和int型指针： ###

//指针类型决定了：解引用的权限有多大
    //指针类型决定，指针走一步，这步能走多远（步长）
    int main()
    {
    	int arr[10] = { 0 };
    	int* p = arr;
    	char* pa = arr;
    
    	printf("%p\n", p);
    	printf("%p\n", p + 1);
    
    	printf("%p\n", pa);
    	printf("%p\n", pa + 1);
    }

这里是输出的结果：

/*
    		0000005EAB50F518
    		0000005EAB50F51C
    		0000005EAB50F518
    		0000005EAB50F519
    		*/

通过结果我们可知，整形指针int\*+1会前进四个byte步长的地址，字符串指针char\*+1会前进一个步长的地址。

### 5.二进制转十六进制 ###

//1 2 3 4 5 6 7 8 9 a b c d e f
    			//11111111
    			//    8421 --> 8 + 4 + 2 + 1 = 15 = 0x的f

（注：看上下对应，二进制中1为十进制的1,11为3,111为7,1111为15，故二进制的1111为十六进制的f）

### 6.野指针 ###

//3.指针指向空间释放
    	int* p = f();		//我们用指针接住f（）传回的地址，接住了！！！
    	*p = 20;			//a已被释放，故对他进行赋值是非法访问内存
    
    	return 0;
    }
    
    
    //避免野指针的方法
    int main()
    {
    	//1.每个局部变量都应该进行初始化，所以局部变量的指针也应该进行初始化操作，此处我们初始化为NULL
    	int* p = NULL;	//操作：右键 NULL 转为定义，可见NULL在c语言中的定义
    
    	//2.明确知道初始化的值
    	int a = 10;
    	int* p = &a;
    
    	//3.c语言本身不会对数据是否发生越界行为进行检查，故我们需要自主进行检查操作
    
    	//4.指针指向释放空间之后，即时置空
    
    	//5.指针在使用之前进行有效性检查
    	//int* p = NULL;	//NULL的内存我们没有权限对0进行访问操作
    	//*p = 10;			//访问异常，p是空指针
    
    	int* P = NULL;
    	if (p != NULL) {	//这里不能写0，待会讨论
    		*p = 10;
    	}
    }

7.指针的运算

1.指针+ - 整数
    2.指针-指针
    3.指针的关系运算
    int main() {
    	//1.指针—+整数
    #define N_values 5
    	float values[N_values] = {'a','b','c','d','e'};
    	float* vp;
    	//指针+-整数：指针关系运算
    	for (vp = &values[0]; vp < &values[N_values];)
    	{
    		*vp++ = 0;
    	}
    }

int main() {
    
    	int arr[10] = { 1,2,3,4,5,6,7,8,9,10, };
    	int* p = arr;
    	int* pend = arr + 9;
    	while (p <= pend) {          //数组遍历
    		printf("%d\n", *p++);    //*p++是*p与p++的结合体
    	}
    	return 0;
    }

指针-指针
    #include <string.h>
     递归法
    my_strlen(char* str)
    {
    	char* start = str;	//将str字符串的首地址赋予* start
    	while (*str)		//当*str值不等于'\0'时，跳出循环
    	{
    		str++;			//地址++
    	}
    	return str - start;	//返回相减之后字节个数
    }
    int main()
    {
    	printf("%d\n", my_strlen("abc"));	//strlen（）求字符串长度，'\0'-'a'=3个字符串长度
    	return 0;
    }

int main()
    {
    	
    	int arr[10] = { 0,1,2,3,4,5,6,7,8,9 };
    	int* p = arr;
    	for (int i = 0; i < 10; i++)
    	{
    		printf("%p <==> %p\n", &arr[i], p + i);			//注：对数组取地址时要用&，不然是得到其值
    	}
    	return 0;
    }

9.指针数组

指针数组
    int main()
    {
    	//[]是一个操作符，2和arr是两个操作数
    	int arr[10] = { 0,1,2,3,4,5,6,7,8,9 };
    	int* p = arr;
    	printf("%d\n", 2[arr]);	
    	printf("%d\n", p[2]);	//p[2] --> *(p + 2)
    	//求值如下：
    	//arr[2] <==> *(arr+2) <==> *(p + 2) <==> *(2 + p) <==> *(2+arr) <==> 2[arr]
    	//arr[2] <==> *(p+2) <==> *(arr+2)
    }

10.二级指针

二级指针变量
    int main()
    {
    	int a = 10;
    	int* pa = &a;		//pa是个指针变量，一级指针
    	
    	//ppa就是个二级指针变量
    	int** ppa = &pa;	//pa指针变量也是个变量，需要一块内存，故它有自己的内存地址，&pa取出pa在内存中起始地址
    
    	int*** ppa = &ppa;
     
    	return 0;
    }
    	*ppa == pa;  *pa == a; 故** ppa == a

//指针数组
    int main()
    {
    	int arr[10];	//整型数组 - 存放整型的数组就是整型数组
    	char ch[10];	//字符数组 - 存放的是字符
    	//指针数组存放的就是指针
    	int* ass[10];	//整型指针数组
    }

11.\*++p和++（\*p）的关系，\*p++和（\*p）++的关系

//润一下看看
    #include<stdio.h>
    int main()
    {
    	int a[5] = { 1,2,3,4,5 };
    	int b[5] = { 1,2,3,4,5 };
    	int c[5] = { 1,2,3,4,5 };
    	int d[5] = { 1,2,3,4,5 };
    	int* p1 = a;
    	int* p2 = b;
    	int* p3 = c;
    	int* p4 = d;
    
    	printf("指针p1：\n");
    	printf("*p1++：%d \t\n", *p1++);
    	printf("a[0]：%d \t\n", a[0]);
    	printf("*p1：%d \t\n", *p1);
    	printf("指针p2：\n");
    	printf("(*p2)++：%d \t\n", (*p2)++);
    	printf("b[0]：%d \t\n", b[0]);
    	printf("*p2：%d \t\n", *p2);
    
    	printf("指针p3：\n");
    	printf("*++p3：%d \t\n", *++p3);
    	printf("c[0]：%d \t\n", c[0]);
    	printf("*p3：%d \t\n", *p3);
    
    	printf("指针p4：\n");
    	printf("++(*p4)：%d \r\n", ++(*p4));
    	printf("d[0]：%d \t\n", d[0]);
    	printf("*p4：%d \t\n", *p4);
    
    	system("pause");
    	return 0;
    }

注：这篇是大佬TinyHorse！写的《【指针】\*p++、(\*p)++、\*++p、++(\*p)都是什么东西？》中的代码，原著更加详细！这里是链接:

[【指针】\*p++、(\*p)++、\*++p、++(\*p)都是什么东西？\_TinyHorse！的博客-CSDN博客][p_p_p_p_TinyHorse_-CSDN]

/*
    
    指针p1：
    
    * p1++：先取指针p1指向的值(a[0])，为1，然后再将指针自增1(a[1])
    a[0]：数组a第一个元素(a[0]) 的值依然为1
    * p1：指针p1指向了数组a第二个元素(a[1])，变为2
    
    指针p2：
    
    (*p2)++：先取指针p2指向的值(b[0]) 为1，然后再将该值加1(b[0] = b[0] + 1)，注意p++为先printf再加1，所以输出为1
    b[0]：数组b第一个元素(b[0]) 的值变为2
    * p2：指针p2依然指向b第一个元素(b[0])，但是值变为2
    
    指针p3：
    
    * ++p3：先将指针p3自增1(指向第二个元素)，然后再取指针所指向的值(c[1])，为2
    c[0]：数组c第一个元素(c[0]) 的值依然为1
    * p3：指针p3指向了数组a第二个元素(c[1])，变为2
    
    指针p4：
    
    ++(*p4)：先取指针p4指向的值(d[0])，再将该值加1(d[0] = d[0] + 1)，注意++p为先加1再printf，所以输出为2
    d[0]：数组d第一个元素(d[0]) 的值变为2
    * p4：指针p4依然指向数组d第一个元素(d[0])，但是值变为2*/

TinyHorse！佬对答案的讲解也是十分详细，这是他对于该知识点的总结

## （二）指针进阶 ##

### 1.指针与数组的差别 ###

int main()
    {
    	char* ps = "Hello World";	//本质是把”Hello bit’’这个字符串的首字符的地址存储在ps中
    	print("%c\n", *ps);		//H；%c是打印字符
    	// 若你想 ： * ps = 'w'；,则必定报错，因为ps是''Hello bit''是常量字符串，是不能改的
    
    	char arr[] = "Hello World";
    	printf("%s\n", arr);	//Hello bit；%s是打印字符串
    	printf("%s\n", ps);		//Hello bit;
    
    	return 0;
    }

### 2.字符串数组和字符串指针的区别 ###

//字符串数组和字符串指针的区别
    int main()
    {
    	char str1[] = "Hello World";
    	char str2[] = "Hello World";
    	char* str3 = "Hello World";
    	//因为Hello World是字符串常量，不能被修改，如果以上面语句输出，可能会导致一些IDE报错
    	//我们应该将上式改为 const char* str3 = "Hello World",这样既可以防止我们之后对这个字符串常量做出修改，又可以让严谨的IDE不报错，这种语法更严谨
    	char* str4 = "Hello World";
    
    	if (str1 == str2)
    		printf("str1、str2相同\n");
    	else
    		printf("str1、str2不相同\n");	//answer;因为两个数组是有不同地址的，所以不同
    
    	if (str3 == str4)
    		printf("str3、str4相同\n");		//answer;因为字符串指针所指的必须是常量字符串，不可以被修改，因此系统一般会让str3、str4都指向Hello World的地址（因为不能改，内存存储时只有一份）
    	else
    		printf("str3、str4不相同\n");
    	return 0;
    }	//字符串数组和字符串指针的区别
    int main()
    {
    	char str1[] = "Hello World";
    	char str2[] = "Hello World";
    	char* str3 = "Hello World";
    	//因为Hello World是字符串常量，不能被修改，如果以上面语句输出，可能会导致一些IDE报错
    	//我们应该将上式改为 const char* str3 = "Hello World",这样既可以防止我们之后对这个字符串常量做出修改，又可以让严谨的IDE不报错，这种语法更严谨
    	char* str4 = "Hello World";
    
    	if (str1 == str2)
    		printf("str1、str2相同\n");
    	else
    		printf("str1、str2不相同\n");	//answer;因为两个数组是有不同地址的，所以不同
    
    	if (str3 == str4)
    		printf("str3、str4相同\n");		//answer;因为字符串指针所指的必须是常量字符串，不可以被修改，因此系统一般会让str3、str4都指向Hello World的地址（因为不能改，内存存储时只有一份）
    	else
    		printf("str3、str4不相同\n");
    	return 0;
    }

3.指针数组

//指针数组
    //数组中存放的是指针（地址）
    int main()
    {
    	int a[] = { 1,2,3,4,5 };
    	int b[] = { 6,7,8,9,10 };
    	int c[] = { 11,12,13,14,15 };
    
    	int* arr[] = { a,b,c };
    	
    	for (int i = 0; i < 3; i++)
    	{
    		for (int j = 0; j < 5; j++)
    		{
    			//printf("%d", *(arr[i] + j));		//此处老是犯错，*解引用才是值，没有*，什么也不是，我们之后做个测试
    			printf("%d", arr[i][j]);			//这是个二维数组，相当于上式，但在理论上与指针数组并不相同，二维数组的元素物理地址都是相邻的，指针数组不是，我们可以简单理解为二维数组就是一个特殊的指针数组
    		}
    		printf("\n");
    	}
    	return 0;
    }

4.二级指针数组（三维数组）

//二级指针数组
    int main()
    {
    	int a[] = { 0,1 };
    	int b[] = { 0,2 };
    	int c[] = { 0,3 };
    	int* arr1[] = { a,b,c };
    	int* arr2[] = { a,b,c };				//在此测试一下，两个指针数组的所有指针相同会怎样？answer：并无影响
    	int** arr[] = { arr1,arr2 };
    
    	for (int i = 0; i < 2; i++)
    	{
    		for (int j = 0; j < 3; j++)
    		{
    			for (int l = 0; l < 2; l++)
    			{
    				printf("%d", arr[i][j][l]);	//这里我们可以写为*(*(*(arr + i) + j) + l)
    			}
    			printf("\n");
    		}
    		printf("\n");
    	}
    	return 0;
    }

[p_p_p_p_TinyHorse_-CSDN]: https://blog.csdn.net/weixin_45099376/article/details/126305045?spm=1001.2014.3001.5506