指针初步理解

垂柳斜下茉莉雨

已于 2023-11-12 23:34:50 修改

阅读量93

点赞数

分类专栏： C语言文章标签： c语言

于 2023-09-05 21:21:32 首次发布

本文链接：https://blog.csdn.net/linxiaogua123/article/details/132500782

版权

C语言专栏收录该内容

8 篇文章 0 订阅

订阅专栏

1. 指针是什么？

指针是什么？

指针理解的 2 个要点：

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

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

总结：

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

单元编号 == 地址 == 指针

指针变量

我们可以通过 & （取地址操作符）取出变量的内存其实地址，把地址可以存放到一个变量中，这个

变量就是指针变量

#include <stdio.h>

int main ()

{

        int a = 10 ; // 在内存中开辟一块空间

        int * p = & a ; // 这里我们对变量 a ，取出它的地址，可以使用 & 操作符。

          //a 变量占用 4 个字节的空间，这里是将 a 的 4 个字节的第一个字节的地址存放在 p 变量

           中，p就是一个之指针变量。

        return 0 ;

}

int *p = &a; —— *说明p是指针变量，int 表示p所指向的a是int型

总结：

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

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

答：1 个字节。

如何编址？

答：经过仔细的计算和权衡我们发现一个字节给一个对应的地址是比较合适的。

对于 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 位机器，如果给 64根地址线。那能编址多大空间，自己计算。

这里我们就明白：

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

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

总结：

1.内存被划分成一个个的内存单元，每个内存单元的大小是1个字节。
2.每个字节的内存单元都有一个编号，这个编号就是地址，地址在C语言中称为指针。
3.地址要存储的话，存放在指针变量中。
4.每个内存单元都有一个唯一的地址来标识。
5.在32位机器上地址的大小是4个字节，所以指针变量的大小也是4个字节。
同理:在64位机器上地址的大小是8个字节，所以指针变量的大小也是8个字节。

2 指针和指针类型

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

在x64环境下，都输出4；在x86环境下，都输出8；

既然都是一样的字节，那么为什么还要区分类型呢？为什么不直接用一种类型的指针呢？

接下来我们就来探讨一下指针类型有什么用。

char * pc = NULL ;

int * pi = NULL ;

short * ps = NULL ;

long * pl = NULL ;

float * pf = NULL ;

double * pd = NULL ;

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

其实：

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

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

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

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

首先写一段代码，用int*

int main()
{
	int a = 0x11223344;
	int* p = &a;//int*
	*p = 0;
	return 0;
}

有图可知他的内存从图一变为图二

如果把int* 改为char*

就只访问了一个字节。

char* p = (char*) & a; 写成这样不会有警告。

从此例中就可看出指针类型是有意义的。指针类型决定了指针进行解引用操作的时候，访问了几个字节。

char*一次访问1个字节

short*一次访问2个字节。

int*一次访问4个字节

double*一次访问8个字节。

再例如：

所以指针类型是有意义的。指针类型决定了指针+1 / -1跳过几个字节 。

char*的指针+1, 跳过1个字节
short*的指针+1,跳过2个字节

int*的指针+1，跳过4个字节
double*的指针+1，跳过8个字节

3 野指针

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

3.1 野指针成因

1 指针未初始化

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

int main()
{
	int* p = (int*)0x11223344;
	*p;

	return 0;

相当于随便找了个地址。

2 指针越界访问

int main()
{
	int arr[10] = { 0 };
	int* p = arr;
	int i = 0;
	for (i = 0; i <= 10; i++)
	{
		*p = -1;
		p++;
	}

	return 0;
}

3 指针指向的空间释放

int* test()
{
	int a = 10;//0x0012ff40
	return &a;
}

int main()
{
	//0x0012ff40
	int *p = test();
	//p就是野指针
	printf("%d\n", *p);//
	return 0;
}

地址还在，但是除了函数以后，a的栈区销毁，非法访问所以p就是野指针。

3.2 如何规避野指针

1. 指针初始化

①如果明确知道指针应该指向哪里，就初始化正确的地址。

int a = 10;

int* p = &a;

②如果指针不知道初始化什么值，为了安全初始化为NULL。

int* p = NULL;
NULL——0

NULL作为地址是，这个地址用户程序是不能访问的。
int * p = NULL;
*p = 100;
会崩溃。

应改为
int * p = NULL;
if (p != NULL)
{
		//..
}
2. 小心指针越界

3. 指针指向空间释放即使置NULL

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

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

4 指针运算

指针+- 整数
指针-指针
指针的关系运算

指针+-整数

指针关系运算

p指向的是数组首元素
for循环中，起始时i=0，p+i 是数组中下标为i的元素的地址
p+i 起始时跳过了i*sizeof(int)个字节

有以下等量关系：

    arr-->p
   arr == p
   arr+i == p+i
   *(arr+i) == *(p+i) == arr[i]
   *(arr+i) == arr[i]
   *(i+arr) == i[arr]

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

以上代码相当于遍历数组中的每一个数并赋值为0。用到了“指针+-整数；指针的关系运算”。

再比如：

for(vp = &values[N_VALUES]; vp > &values[0];)
{
    *--vp = 0;
}

可简化代码：

for(vp = &values[N_VALUES-1]; vp >= &values[0];vp--)
{
    *vp = 0;
}

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

标准规定：

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

指针-指针

指针-指针的前提：两个指针指向同一块区域，指针类型时相同的
指针-指针差值的绝对值，指针和指针之间的元素个数

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

	printf("%d\n", &arr[9] - &arr[0]); //9
	printf("%d\n", &arr[0] - &arr[9]); //-9

	return 0;
}

以前，我们在用递归模拟strlen函数的时候，通常会采用以下写法：

size_t my_strlen(char* str)
{
	if (*str == '\0')
		return 0;
	else
		return 1 + my_strlen(str + 1);
}
 
int main()
{
	char arr[] = "abc";
	size_t len = my_strlen(arr);//传递的是数组首元素的地址
	printf("%zd\n", len);
 
	return 0;
}

现在，我们可以用指针-指针的写法

//size_t my_strlen(char* str)
//{
//	char* start = str;
//	while (*str != '\0')
//	{
//		str++;
//	}
//	return str - start;
//}


size_t my_strlen(char* str)
{
	char* start = str;
	while (*str)
	{
		str++;
	}
	return str - start;
}

//以上两种写法都是对的

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

	return 0;
}

5 指针和数组

指针就是指针，指针变量就是一个变量，用来存放地址，指针变量的大小是4/8个。
数组就是数组，可以存放一组数，数组的大小是取决于元素的类型和个数。
数组的数组名是数组首元素的地址，地址是可以访问指针变量的，通过指针可以访问一个数组的元素。

数组名是数组首元素的地址

2个例外：

1、sizeof(数组名)，这里的数组名表示整个数组，计算的是整个数组的大小，单位是字节。
2、&数组名，这里的数组名表示整个数组，取出的是整个数组的地址，数组的地址和数组首元素的地址取出来的值是一样的，但是类型和意义都不同。

int main()
{
	int arr[10] = { 0 };
	int *p = arr;
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		*(p + i) = i;
	}
	for (i = 0; i < 10; i++)
	{
		printf("%d ", *(arr+i)); // *(p+i) 或 arr[i] 或 p[i] 
	}
	for (i = 0; i < 10; i++)
	{
		printf("%p === %p\n", arr + i, p + i);
	}
	return 0;
}

6 二级指针

二级指针变量是存放一级指针变量的地址的。


int main()
{
	int a = 10;
	int* p =  &a;//p是指针变量，一级指针变量
	int* * pp = &p;//pp指针变量，二级指针变量

	**pp = 20;
	printf("%d\n", a);//20

	//int** * ppp = &pp;//ppp是指针变量，三级指针变量
	//...
	return 0;
}

如图：

7 指针数组

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

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

数组我们已经知道整形数组，字符数组。

字符数组：存放字符的数组

整型数组：存放整形的数组

指针数组：存放指针（地址）的数组

比如char* arr1[5] = 5 ; double* arr2[4] = 5 ;就是存放字符指针的数组。

使用指针数组，模拟一个二维数组。

int main()
{
	//使用指针数组，模拟一个二维数组
	int arr1[] = { 1,2,3,4,5 };
	int arr2[] = { 2,3,4,5,6 };
	int arr3[] = { 3,4,5,6,7 };

	//指针数组
	int* arr[] = { arr1, arr2, arr3 };

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