#指针详解#通俗易懂#巩固知识#基础必会

AAA废品回收站陈师傅

已于 2022-12-28 20:28:46 修改

阅读量185

点赞数 2

分类专栏： c语言基础知识文章标签：开发语言

于 2022-12-28 20:23:57 首次发布

本文链接：https://blog.csdn.net/m0_73673820/article/details/128378070

版权

c语言基础知识专栏收录该内容

7 篇文章 0 订阅

订阅专栏

1.指针是什么

指针是什么？

指针理解的 2 个要点：

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

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

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

通俗理解：

把内存划分为一个一个小格子，一个格子占一个一个字节的空间，把内存单元编号，通过内存编号找到内存单元，编号称为地址，地址也称为指针。

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

#include<stdio.h>
int main()
{
	int a = 10;
	int* pa = &a;//pa为指针变量存放变量a的地址
	printf("%p\n%p\n", &a, pa);
	return 0;
}

指针的大小是多少？//指针的大小在32位平台是4个字节，在64位平台是8个字节

如何编址？

对于 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 位机器类同。

总结：

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

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

2.指针和指针类型

char  *pa = NULL;
int   *pb = NULL;
short *pc = NULL;
long  *pd = NULL;
float *pe = NULL;
double *pf = NULL;

指针类型的意义：

1.指针类型决定了指针解引用操作的时候一次性访问几个字节，也就是访问权限

2.指针类型决定了指针的步长，指针+1，跳过几个字节

2.1指针+-指数

#include<stdio.h>
int main()
{
	int a = 10;
	int* pa = &a;
	char* pa2 = (char*)&a;
	printf("%p\n", pa);
	printf("%p\n", pa + 1);
	printf("%p\n", pa2);//与pa地址相同
	printf("%p\n", pa2+1);//与pa+1不同
	return 0;
}

2.2指针的解引用

#include<stdio.h>
int main()
{
	int i = 0;
	int n = 0x11223344;
	char* pc = (char*)&n;
	/*for (i=0;i<4;i++)
	{
		*pc = 0;
		pc++;
	}
	printf("%d\n", n);*/
	int* pi = &n;
	*pi = 0; 
	printf("%d\n", n);//与上面循环处理后打印结果一样
	return 0;
}

3.野指针

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

3.1野指针成因

1.指针为初始化

#include <stdio.h>
int main()
{ 
 int *pa;//局部变量指针未初始化，默认为随机值
 *pa = 20;
 return 0;
}

2.指针越界访问

#include <stdio.h>
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;
}

3.指针指向空间释放

#include<stdio.h>
int* test()//函数用时才占用空间，用完就把a 的空间还回去
{
	int a = 10;
	return &a;
}
int main()
{
	int* p = test();
	printf("hehe\n");
	printf("%d\n", *p);//打印结果不为10；
}

3.2如何规避野指针

1. 指针初始化

2. 小心指针越界

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

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

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

以后定义int* p=NULL；

4.指针运算（指针的大小比较）

4.1指针+-整数

#include<stdio.h>
int main()
{
	int arr[5] = { 0 };
	int* ap = arr;
	for (ap = arr; ap < &arr[5];)
	{
		*ap = 1;
		ap++;//一起写成*ap++=1,++优先级高于*，后置++，先使用后加加
	}
	return 0;
}

4.2指针-指针

条件：两个指针要指向同一块空间

结论：指针-指针绝对值得到的是两个指针之间的元素个数

#include<stdio.h>
//第一种写法
int my_strlen(char* str)
{
	int count = 0;
	while(*str != 0)
	{
		count++;
		str++;
	}
	return count;
}

int main()
{
	//写一个函数求字符串的长度
	char arr[50];
	scanf("%s", arr);
	int num = my_strlen(arr);
	printf("%d\n", num);
	return 0;
}

#include<stdio.h>
//第二种写法指针-指针
int my_strlen(char* str)
{
	char* start = str;

	while(*str != 0)
	{
		str++;
	}
	return str - start;
}
int main()
{
	//写一个函数求字符串的长度
	char arr[50];
	scanf("%s", arr);
	int num = my_strlen(arr);
	printf("%d\n", num);
	return 0;
}

5.指针和数组

指针和数组区别：

1.指针和数组面向不同对象，口语中的指针是指针变量，存放地址，大小4/8个字节，数组是一组相同类型元素的集合，可以放多个元素，大小取决于元素个数与元素类型

2.数组的数组名是首元素地址，地址是可以放在指针变量中，可以通过指针变量访问

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

6.二级指针

int a=10;

int* pa=&a;

int** ppa=&pa;

a的地址放在pa中，pa的地址放在ppa中

pa是一级指针，ppa是二级指针

*ppa是pa的地址，**ppa是a的值，*pa也是a的值

7.指针数组

概率：用来存放指针的数组

#include<stdio.h>
int main()
{
	int i = 0;
	int a[] = { 5,2,0,1 };
	int b[] = { 2,0,1,3 };
	int c[] = { 1,3,1,4 };
	int* arr[3] = { a,b,c };
	for (i = 0; i < 3; i++)
	{
		int j = 0;
		for (j = 0; j < 4; j++)
		{
			printf("%d ", arr[i][j]);
		}
		printf("\n");
	}
	return 0;
}