S6---初阶指针

从前慢，现在也慢

已于 2023-07-11 23:07:33 修改

阅读量143

点赞数 1

分类专栏： C语言初阶文章标签：数据结构开发语言 c语言

于 2023-02-05 16:40:50 首次发布

本文链接：https://blog.csdn.net/wangjiushun/article/details/128793871

版权

C语言初阶专栏收录该内容

16 篇文章 0 订阅

订阅专栏

1.指针是什么?

2.指针和指针类型

3.野指针

4.指针运算

5.指针和数组

6.二级指针

7.指针数组

1.指针是什么？

要理解指针我们首先理解内存！

指针理解的2个要点：

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

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

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

指针变量：

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

代码实例：

#include<stdio.h>

int main()
{
	int a = 10;//在内存中开辟4个字节的空间
	int* pa = &a;//这里我们要取出变量a的地址，可以使用&操作符
	//a变量占用4个字节的空间，这是将a的4个字节的第一个字节的地址存放在pa变量中，pa就是一个指针变量
	printf("&a--->%p\n", &a);
	printf("pa--->%p\n", pa);
	//那我们怎么通过pa中的地址，找到a?
	//*解引用，*pa就是a
	*pa = 20;//*-解引用
	printf("a=%d\n", a);
	return 0;
}

运行结果：

总结：

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

那这里的问题是？

1、一个小的单元到底是多大？

1个字节

2、如何编址？

这里我们就明白：

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

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

总结：

1、指针变量是用来存放地址的，地址是唯一标示一个内存单元的

2、指针的大小在32位平台是4个字节，在64位平台是8个字节

2.指针和指针类型

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

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

准确的说：有的

我们给指针变量相应的类型：

char* pc=NULL;

short* ps=NULL;

int* pi=NULL;

long* pl=NULL;

float* pf=NULL;

double* pb=NULL;

这里可以看到，指针的定义方式是：type+*

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

2.1 指针的解引用

代码实例：

//2.指针和指针的类型
//2.1 指针的解引用

int main()
{
	int a = 0x11223344;
	//代码1
	//int* pi = &a;
	//*pi = 0;//重点在调试的过程中观察内存的变化

	//代码2
	char* pc = &a;
	*pc = 0;//重点在调试的过程中观察内存的变化
	return 0;
}

//指针类型其实是有意义的
//指针类型决定了，指针进行解引用操作的时候，一次性访问几个字节
//如果是char*的指针，解引用访问1个字节
//如果是int*的指针，解引用访问4个字节

调试截图：

代码1：

代码2：

总结：指针的类型决定了，对指针解引用的时候有多大的权限（能操作几个字节）

2.2 指针+-整数

代码1：

//2.2指针+-整数

#include<stdio.h>

int main()
{
	int a = 0x11223344;
	int* pi = &a;
	char* pc = (char*)&a;//a是int型的，&a是整形指针变量存放int*
	printf("%p\n", pi);
	printf("%p\n", pi+1);
	printf("%p\n", pc);
	printf("%p\n", pc+1);
	return 0;
}

//指针类型决定指针的步长（指针+1到底跳过几个字节）
//如字符指针+1，跳过1个字节
//如整形指针+1，跳过4个字节

运行结果：

总结：

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

通过char*修改a:

//通过char*修改a=0
int main()
{
	int a = 0x11223344;
	char* pc = (char*)&a;
	int i = 0;
	for (i = 0; i < 4; i++)
	{
		*pc = 0;
		pc++;
	}
	return 0;
}

3. 野指针

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

3.1 野指针成因

1. 指针未初始化

//1.指针未初始化

int main()
{
	int* p;//p是一个局部变量，没有初始化，默认为随机值
	*p = 20;
	return 0;
}

2. 指针越界访问

//2.指针越界访问

#include<stdio.h>

int main()
{
	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
	int* p = arr;//数组名是数组首地址
	int i = 0;
	for (i = 0; i <= 10; i++)
	{
		//当指针指向的范围超出数组arr的范围时，p就是野指针
		//第十一次循环的时候指针就越界访问了。是野指针
		printf("%d ", *p);
		p++;
	}
	return 0;
}

运行结果：

3.指针指向的空间释放

代码1：

//代码1

#include<stdio.h>
int* test()
{
	int a = 10;
	return &a;
}

int main()
{
	int* p = test();
	printf("%d\n", *p);//虽然结果还是10，但是这是因为函数栈帧没有被破坏
	return 0;
}

代码2：

//代码2

#include<stdio.h>
int* test()
{
	int a = 10;
	return &a;
}

int main()
{
	int* p = test();
	printf("hehe\n");//破坏函数栈帧
	printf("%d\n", *p);//随机值，函数栈帧被破坏
	return 0;
}

3.2 如何规避野指针

1. 指针初始化（没有明确指向的指针初始化NULL）

2. 小心指针越界

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

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

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

补充：NULL—本质是0，在C++可以直接写0，但是C不可以，C要写成NULL
//为什么要写成NULL，变量一旦赋值为NULL你就知道这是一个指针，让你容易识别
//0地址是用户不能使用的，使用的话程序会崩溃（int* p=NULL;*p=2;(使用0地址)）

//3.2 如何规避野指针
#include<stdio.h>

int main()
{
	//1、指针初始化：有明确的的指向
	int a = 10;
	int* pa = &a;
	//不知道指针明确指向的地址时候，初始化NULL
	int* p = NULL;//NULL（本质是0）-空指针，专门用来初始化指针
	//这相当与把野狗栓好了，但是要知道它还是很危险的

	//5、指针使用之前检查有效性
	if (p != NULL)
	{
		*p = 20;
	}
	return 0;
}

4. 指针运算

4.1 指针+-整数

4.2 指针-指针

4.3 指针的关系运算

4.1 指针+-整数

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

4.2 指针-指针

前提：两个指针要指向同一块空间

作用：指针减指针的绝对值，得到的是两个指针之间的元素个数

代码实例：

代码1：

//指针-指针
//前提：两个指针要指向同一块空间

#include<stdio.h>

int main()
{
	int arr[10] = { 0 };
	printf("%d\n", &arr[9] - &arr[0]);//9
	printf("%d\n", &arr[0] - &arr[9]);//-9

	//注意：必须是指向同一块空间
	//char arr1[5] = { 0 };
	//printf("%d\n", &arr1[0] - &arr[2]);//编译器警告：从“int*”到char*的类型不兼容
	return 0;
}

代码2：

写一个函数求字符串的长度

//写一个函数求字符串的长度
//1、计数器
//2、指针-指针
//3、递归

#include<stdio.h>

//计数器
int my_strlen(char* str)
{
	int count = 0;
	//求字符串的长度，其实是统计\0之前的字符的个数
	while (*str != '\0')
	{
		count++;
		str++;
	}
	return count;
}

//指针-指针
int my_strlen1(char* str)
{
	char* start = str;
	while (*str != '\0')
	{
		str++;
	}
	return str - start;
}

//递归
int my_strlen2(char* str)
{
	if (*str != '\0')
	{
		return 1 + my_strlen2(str + 1);
	}
	else
	{
		return 0;
	}
}

int main()
{
	char arr[] = "abcdef";
	int len = my_strlen(arr);
	int len1 = my_strlen1(arr);
	int len2 = my_strlen2(arr);
	printf("%d %d %d\n", len,len1,len2);
	return 0;
}

4.3 指针的关系运算（比较指针的大小）

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

标准规定：

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

5. 数组和指针

指针与数组不等价，理解：

1、指针和数组是不同的对象

①指针是一种变量，存放地址的，大小4/8字节

②数组是一组相同类型元素的集合，是可以放多个元素的，大小取决于元素个数和元素的类型

2、（二者的联系）数组的数组名是数组首元素的地址，地址可以放在指针变量中，通过指针访问数组

代码实例：

#include<stdio.h>

int main()
{
	int arr[10] = { 0 };

	//通过指针来给数组赋值1~10
	int* p = arr;
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		*(p + i) = i + 1;
	}

	//通过指针来打印数组
	p = arr;
	for (i = 0; i < 10; i++)
	{
		printf("%d ", *(p + i));
	}
	printf("\n");

	//通过数组下标来打印数组
	for (i = 0; i < 10; i++)
	{
		printf("%d ", arr[i]);
	}

	return 0;
}

6. 二级指针

二级指针是什么？

指针变量也是变量，有变量就有地址，存放一级指针变量的地址的变量就是二级指针。

对于二级指针的运算有：

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

代码实例：

#include<stdio.h>

int main()
{
	int a = 10;
	int * pa = &a;//一级指针变量
	int* * ppa = &pa;//二级指针变量
	//int*** ppa = &ppa;//三级指针变量
	**ppa = 50;
	printf("%d\n", a);//50
	return 0;
}

7. 指针数组

指针数组是指针还是数组？

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

上面只是让我们更好的理解指针数组，但是指针数组是怎么使用的呢？

代码实例：

使用一维数组，模拟一个3行4列的二维数组

//使用一维数组，模拟一个3行4列的二维数组

#include<stdio.h>

int main()
{
	int a[4] = { 1, 2, 3, 4 };
	int b[] = { 2, 3, 4, 5 };
	int c[] = { 3, 4, 5, 6 };
	int* arr[3] = { a, b, c };

	//打印
	int i = 0;
	for (i = 0; i < 3; i++)
	{
		int j = 0;
		for (j = 0; j < 4; j++)
		{
			printf("%d ", arr[i][j]);
		}
		printf("\n");
	}

	return 0;
}