[C语言]指针初阶

最新推荐文章于 2023-01-12 10:18:05 发布

H_JinYun

最新推荐文章于 2023-01-12 10:18:05 发布

阅读量100

点赞数

分类专栏： C语言学习文章标签： c语言开发语言后端

本文链接：https://blog.csdn.net/H_JinYun/article/details/122348440

版权

C语言学习专栏收录该内容

13 篇文章 0 订阅

订阅专栏

1.指针的含义

内存 ——> 内存单元 ——> 地址(由地址可以指向内存) —— 指针

（划分） （编号） |（存放地址）

指针变量

1.1要点：

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

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

3.指针就是地址，口语中说的指针通常指的是指针变量

1.2指针变量：

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

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

3.指针的大小在32位平台是4个字节，在64位平台是8个字节。
#include <stdio.h>
int main()
{
	int a = 10;//在内存中开辟一块空间
	int* p = &a;//这里我们对变量a，取出它的地址，可以使用&操作符。
	            //a变量占用4个字节的空间，这里是将a的4个字节的第一个字节的地址存放在p变量中，p就是一个之指针变量。
	*p = 20;//可以通过指针改变a的值
	return 0;
}

2.指针和指针类型

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

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

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

指针类型的意义

1.解引用的权限

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

比如：char* 的指针解引用就只能访问一个字节，而 int* 的指针的解引用就能访问四个字节。

//1.指针类型决定了：指针解引用的权限有多大
int main()
{
	int a = 0x11223344;
	/*int* pa = &a;
	*pa = 0;*/
	char* pc = &a;
	*pc = 0;
	return 0;
}

初始：

int 指针类型：

char 指针类型

以及在数组中使用不同指针类型的对比：

2.步长

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

int main()
{
	int arr[10] = {0};
	int* p = arr;
	char* pc = arr;
	printf("%p\n", p);
	printf("%p\n", p+1);

	printf("%p\n", pc);
	printf("%p\n", pc+1);
	return 0;
}

3.野指针

概念

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

成因

1.指针未初始化

int main()

{

   int *p;//局部变量指针未初始化，默认为随机值

*p = 20;

return 0;

}

2.指针越界访问

  int main()

{

int arr[10] = {0};

int *p = arr;

int i = 0;

for(i=0; i<=11; i++)

{

//当指针指向的范围超出数组arr的范围时，p就是野指针

  *(p++) = i;

}

return 0;

}

3.指针指向的空间释放

int* test()

{

int a = 10;

return &a;————————>a的生命周期只在函数内，临时创建了内存空间，设地址为 0x0012FF40

}

int main()

{

int* p = test();————> 0x0012FF40传给了p

*p = 20;————> 但此时无法再访问操作 0x0012FF40的空间

return 0;

}

规避野指针措施

1.指针初始化（int *p = NULL;）

2.小心指针越界

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

4.指针使用前检查有效性

if ( p != NULL）

4. 指针运算

指针 + - 整数

#define N_VALUES 5
float values[N_VALUES];
float *vp;
//指针+-整数；指针的关系运算
for (vp = &values[0]; vp < &values[N_VALUES];)
{
     *vp++ = 0;
}

指针 - 指针

指针 - 指针得到的是两个指针之前的元素个数，前提是两个指针指向同一块空间
//指针-指针求字符串长度
int my_strlen(char* str)
{
	char* start = str;
	while (*str != '\0')
	{
		str++;
	}
	return str-start;
	
}

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

指针的关系运算

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

第一种写法：
#define N_VALUES 5
float values[N_VALUES];
float *vp;
//指针+-整数；指针的关系运算
for (vp = &values[0]; vp < &values[N_VALUES];)
{
     *vp++ = 0;
}
第二种写法：(应避免)
for (vp = &values[N_VALUES - 1]; vp >= &values[0]; vp--)
{
	*vp = 0;
}

5.指针和数组

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++)
	{
		printf("%p<==>%p\n", &arr[i], p + i);
	}
	return 0;
}

先看一段代码：可见数组名和数组首元素的地址是一样的

那我们就可以直接通过指针来访问数组。

等价：arr[2] <==> *(p+2) / *(arr+2) <==> *(2+p) / *(2+arr) <==> 2[arr]

解释以上写法：

1.[ ]——是一个操作符，2和arr是两个操作数；

2.a + b == b + a (交换律同样适用）；

3.编译器实际工作原理—— arr[2] → *（arr + 2）→ *(2 + arr) → 2[arr]

6.二级指针

//二级指针
int main()
{
	int a = 10;
	int* pa = &a;//pa是指针变量，一级指针
    
	//ppa就是一个二级指针变量
	int** ppa = &pa;//pa也是个变量，&pa取出pa在内存中的起始地址

	return 0;
}

写法：

int* p = &a; int* *ppa = &pa;

↓ ↓

（说明指向元素的类型）（说明ppa是指针）

理解：

pa存放变量a的地址，但pa同样也是变量，所以ppa可以存放pa的地址

二级指针操作过程： *ppa == pa，*pa == a，**ppa == a