程序猿入门攻略（十）——指针

最新推荐文章于 2022-06-23 08:00:00 发布

Yuan_o_

最新推荐文章于 2022-06-23 08:00:00 发布

阅读量175

点赞数

分类专栏： C入门文章标签： c++ c语言算法

本文链接：https://blog.csdn.net/Yuan_o_/article/details/124879993

版权

C入门专栏收录该内容

29 篇文章 2 订阅

订阅专栏

1、指针是什么？

指针的理解有两个要点：

指针是内存中一个最小单元的编号，也就是地址
平时口语中说的指针，通常指的是指针变量，是用来存放内存地址的变量

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

我们的电脑内存很大，有8G的、16G的，那这些内存空间是如何管理的呢？
它们是切割成内存单元——1byte（字节）来管理的。
如图：

我们为了更方便的找到每一个内存单元，给它们进行编号，这个编号就是我们说的地址（指针）

#include <stdio.h>

int main()
{
	int a = 10;//a是整型变量，占用4个字节的内存空间

	return 0;
}

当我们写了这个代码后，a就存储在了内存中的4个内存单元中，当我们调试之后就会得到a所在的四个内存单元的起始地址（这个地址是随机生成的，每次运行，地址不一定相同）。

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

#include <stdio.h>

int main()
{
	int a = 10;//a是整型变量，占用4个字节的内存空间
	int* pa = &a;//我们使用&（取地址操作符）取出a的地址，
    //将a4个字节的第一个字节的地址存放在pa变量中，pa就是一个指针变量

	return 0;
}

补充：
对于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) 4GB的空间进行编址。

同样的方法我们可以算出64位机器能编址的空间有多大。

由此可知：

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

总结：

指针是用来存放地址的，地址是唯一标识一块地址空间的。
指针的大小在32位平台是4个字节，在64位平台是8个字节。

举例：

#include <stdio.h>
int main()
{
	char* pc = NULL;
	short* ps = NULL;
	int* pi = NULL;
	double* pd = NULL;

	//sizeof 返回值得类型时无符号整形 unsigned int
	printf("%zu\n", sizeof(pc));
	printf("%zu\n", sizeof(ps));
	printf("%zu\n", sizeof(pi));
	printf("%zu\n", sizeof(pd));

	return 0;
}

当我们在VS编译器的X86（也就是32位环境下）编译出效果：

当我们在VS编译器的X64（也就是64位环境下）编译出效果：

2、指针和指针类型

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

当有这样的代码：

int num = 10;
p = &num;

要将&num（num的地址）保存到p中，我们知道p就是一个指针变量，那它的类型是怎样的呢？
我们要给指针变量相应的类型：

char* pa = NULL;
int* pi = NULL;
short* ps = NULL;
long* pl = NULL;
float* pf = NULL;
double* pd = NULL;

这里可以看到，指针的定义方式是：type + *
其实：
char*类型的指针是为了存放char类型变量的地址。
short*类型的指针是为了存放short类型变量的地址。
int*类型的指针是为了存放int类型变量的地址。
那指针类型的意义是什么？

2.1 指针 + - 整数

#include <stdio.h>
int main()
{
	int n = 10;
	char* pc = (char*)&n;
	int* pi = &n;

	printf("%p\n", &n);
	printf("%p\n", pc);
	printf("%p\n", pc+1);
	printf("%p\n", pi);
	printf("%p\n", pi+1);

	return 0;
}

当我们使用char*进行+1操作时，跳过1个字节
当我们使用int*进行+1操作时，跳过4个字节

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

2.2 指针的解引用

举例：

#include <stdio.h>
int main()
{
	int a = 0x11223344;
	int* pa = &a;
	*pa = 0;

	return 0;
}

int*解引用访问4个字节

#include <stdio.h>
int main()
{
	int a = 0x11223344;
	//int* pa = &a;
	//*pa = 0;

	char* pc = &a;
	*pc = 0;
	return 0;
}

char*解引用访问1个字节

补充：

#include <stdio.h>
int main()
{
	int a = 0;
	int* pi = &a;
	float* pf = &a;

	*pi = 100;
	*pf = 100;

	return 0;
}

int解引用访问4个字节，+1是跳过4个字节
float解引用访问4个字节，+1是跳过4个字节
那么int和float是不是可以通用呢？

答案是不可以，因为他们在内存中的存储方式是不同的。

3、野指针

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

3.1 野指针成因

1、指针未初始化

#include <stdio.h>
int main()
{
    int* p;//局部变量指针未初始化，默认为随机值
    *p = 20;//非法访问内存，这里的p就是野指针
    return 0;
}

2、指针越界访问

#include <stdio.h>
int main()
{
    int arr[10] = {0};
    int *p = arr;
    int i = 0;
    for(i=0; i<=11; i++)
   {
        //当指针指向的范围超出数组arr的范围时，p就是野指针
        *p = i;
        p++;
   }
    return 0;
}

3、指针指向的空间释放

#include <stdio.h>

int* test()
{
	int a = 10;
	return &a;
}
int main()
{
	int* p = test();

	return 0;
}

这里虽然p里面存了地址，但是并没有权力去访问他，在test函数结束时，这个地址就被释放了

3.2 如何规避野指针

指针初始化
小心指针越界
指针指向空间释放及时置NULL
避免返回局部变量的地址
指针使用之前检查有效性

具体操作：

#include <stdio.h>
int main()
{
	//明确的给指针赋值
	int a = 10;
	int* p = &a;
	*p = 20;

	//当不知道给指针赋什么值时，赋为NULL
	//NULL本质上就为0
	int* p2 = NULL;
	*p2 = 100;//err
	//当我们把指针赋值为NULL时，就不能直接解引用了

	//正确方法
	int* p3 = NULL;
	if (p3 != NULL)
	{
		*p3 = 100;
	}

	return 0;
}

4、指针运算

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

4.1 指针 + - 整数

#include <stdio.h>
#define N_VALUES 5
int main()
{
	float values[N_VALUES];
	float* vp;
	//指针 + - 整数，指针的关系运算
	for (vp = &values[0]; vp < &values[N_VALUES];)
	{
		*vp++ = 0;
    }
    
	return 0;
}

在上面的代码中，*vp++可以拆分为：*vp=0，vp++
注意区分(*vp)++和*vp++；(*vp)++是对vp所指向的内容++

ep:
给数组arr初始化的方式

#include <stdio.h>
int main()
{
	int arr[10] = { 0 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	int i = 0;
	
	//数组下标的写法
	for (i = 0; i < sz; i++)
	{
		arr[i] = i;
	}

	//指针解引用，指针 + 整数
	//方式一
	int* p = arr;
	for (i = 0; i < sz; i++)
	{
		*p = i;
		p++;
	}
	//方式二
	for (i = 0; i < sz; i++)
	{
		*(p + i) = i;
	}

	for (i = 0; i < sz; i++)
	{
		printf("%d ", arr[i]);
	}
	return 0;
}

4.2 指针 - 指针

#include <stdio.h>
int main()
{
	int arr[10] = { 0 };
	printf("%d\n", &arr[9] - &arr[0]);
	printf("%d\n", &arr[0] - &arr[9]);

	return 0;
}

指针 - 指针（的绝对值）得到的是指针和指针之间元素的个数
注：
不是所有的指针都能相减
指向同一块空间的2个指针才能相减！

应用：（求字符串长度）

#include <stdio.h>
#include <string.h>
//求字符串长度

//方法一
int main()
{
	int len = strlen("abcdef");
	printf("%d\n", len);

	return 0;
}

//方法二
int my_strlen(char* str)
{
	int count = 0;
	while (*str != '\0')
	{
		count++;
		str++;
	}
	return count;
}
int main()
{
	int len = my_strlen("abcdef");
	printf("%d\n", len);

	return 0;
}

//方法三（指针 - 指针）
int my_strlen(char* str)
{
	char* start = str;
	while (*str != '\0')
	{
		str++;
	}
	return str - start;
}
int main()
{
	int len = my_strlen("abcdef");
	printf("%d\n", len);

	return 0;
}

4.3 指针的关系运算

#define N_VALUES 5
float valued[N_VALUES];
float *vp;
for(vp = &values[N_VALUES];vp > &valued[0];)
{
    *--vp = 0;
}

我们简化代码，修改如下：

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

这个简化代码在绝大部分的编译器上是可以顺利完成任务的，但是我们还是应该避免这样写，因为标准并不保证他可行。
标准规定：

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

5、指针和数组

ep：

#include <stdio.h>
int main()
{
	int arr[10] = { 1,2,3,4,5,6,7,8,9,0 };
	printf("arr    =%p\n", arr);
	printf("&arr[0]=%p\n", &arr[0]);
	return 0;
}

res：

可见数组名和数组首元素的地址是一样的。
结论：数组名表示的事数组首元素的地址。

既然可以吧数组名当成地址存放到一个指针中，我们使用指针来访问一个数组就成为可能。
ep：

#include <stdio.h>
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("&arr[%d] = %p   <====> p+%d = %p\n", i, &arr[i], i, p + i);
    }
    return 0;
}

res：

所以p+i其实计算的是数组arr下标为i的地址。
那么我们就可以直接通过指针来访问数组。

#include <stdio.h>

//指针访问数组
void test(int* p, int sz)
{
	int i = 0;
	for (i = 0; i < sz; i++)
	{
		printf("%d ", *(p + i));
	}
}

//数组名访问数组
void test(int arr[], int sz)
{
	int i = 0;
	for (i = 0; i < sz; i++)
	{
		printf("%d ", arr[i]);
	}
}

int main()
{
	int arr[10] = { 0 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	test(arr, sz);
	return 0;
}

6、二级指针

#include <stdio.h>
int main()
{
	int a = 10;
	int* p = &a;
	*p = 20;

	printf("%d\n", a);
	return 0;
}

这里的*p是一个指针变量，是一级指针变量。

指针变量也是变量，是变量就有地址，那指针变量的地址存放在哪里？

#include <stdio.h>
int main()
{
	int a = 10;
	int* p = &a;
	int** pa = &p;
	**pa = 20;

	printf("%d\n", a);
	return 0;
}

上面代码中a的地址存放在p中，p的地址存放在pa中。
p是一级指针，pa是二级指针。

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

7、指针数组

指针数组是指针还是数组？
答案是数组。是存放指针的数组。
数组我们已经知道整型数组，字符数组。

int arr1[5];
char arr2[6];

那指针数组是怎样的？
int* arr3[5];//是什么？
arr3是一个数组，有五个元素，每个元素是一个整形指针。

ep1：

#include <stdio.h>
int main()
{
	int a = 10;
	int b = 20;
	int c = 30;

	int* pa = &a;
	int* pb = &b;
	int* pc = &c;

	return 0;
}

上面代码，当我们有很多整型需要取地址时，我们一个一个列出来，就麻烦了。

#include <stdio.h>
int main()
{
	int a = 10;
	int b = 20;
	int c = 30;

	//int* pa = &a;
	//int* pb = &b;
	//int* pc = &c;

	int* parr[10] = { &a,&b,&c };//指针数组

	int i = 0;
	for (i = 0; i < 3; i++)
	{
		printf("%d ", *(parr[i]));
	}
	return 0;
}

ep2：

#include <stdio.h>

//打印二维数组
int main()
{
	int arr[3][4] = { 1,2,3,4,2,3,4,5,3,4,5,6 };
	int i = 0;
	int j = 0;
	for (i = 0; i < 3; i++)
	{
		for (j = 0; j < 4; j++)
		{
			printf("%d ", arr[i][j]);
		}
		printf("\n");
	}
	return 0;
}

//利用指针数组打印二维数组
int main()
{
	int arr1[4] = { 1,2,3,4 };
	int arr2[4] = { 2,3,4,5 };
	int arr3[4] = { 3,4,5,6 };
	
    int* parr[3] = { arr1,arr2,arr3 };
	int i = 0;
	int j = 0;
	for (i = 0; i < 3; i++)
	{
		for (j = 0; j < 4; j++)
		{
			printf("%d ", parr[i][j]);
		}
		printf("\n");
	}
	return 0;
}

注：arr[i] 等价于 *(arr + i)； []相当于解引用

Yuan_o_

关注

0
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
程序猿入门攻略（十）——指针

1、指针是什么？指针的理解有两个要点：指针是内存中一个最小单元的编号，也就是地址平时口语中说的指针，通常指的是指针变量，是用来存放内存地址的变量总结：指针就是地址，口语中说的指针通常指的是指针变量。我们的电脑内存很大，有8G的、16G的，那这些内存空间是如何管理的呢？它们是切割成内存单元——1byte（字节）来管理的。如图：我们为了更方便的找到每一个内存单元，给它们进行编号，这个编号就是我们说的地址（指针）#include <stdio.h>int main()
复制链接

扫一扫