详解进阶指针

最新推荐文章于 2024-06-13 10:05:06 发布

EDG.TSWS

最新推荐文章于 2024-06-13 10:05:06 发布

阅读量523

点赞数 6

分类专栏： c语言篇文章标签：开发语言 c语言

本文链接：https://blog.csdn.net/V5Jackeylove/article/details/133582878

版权

c语言篇专栏收录该内容

16 篇文章 0 订阅

订阅专栏

本章内容

相信大家对于指针的概念都不陌生，那么我们在这里深入探究一下指针的各种用法。
指针的基本内容：

指针就是个变量，用来存放地址，地址唯一标识一块内存空间。
指针的大小是固定的4/8个字节（32位平台/64位平台）。
指针是有类型，指针的类型决定了指针的±整数的步长，指针解引用操作的时候的权限。

字符指针

在指针的类型中我们知道有一种指针类型为字符指针 char* ;
一般使用:

int main()
{
    char ch = 'w';
    char *pc = &ch;
    *pc = 'w';
    return 0;
}

还有一种使用方式如下：

int main()
{
    const char* pstr = "hello bit.";//这里是把一个字符串放到pstr指针变量里了吗？
    printf("%s\n", pstr);
    return 0;
}

但事实上pstr中存放的仅有”h“，我们可以来打开监视窗口开查看一下
在这里插入图片描述
既然我们已经知道了，不妨来看一下这样一道题：

#include <stdio.h>
int main()
{
    char str1[] = "hello bit.";
    char str2[] = "hello bit.";
    const char *str3 = "hello bit.";
    const char *str4 = "hello bit.";
    if(str1 ==str2)
 printf("str1 and str2 are same\n");
    else
 printf("str1 and str2 are not same\n");
       
    if(str3 ==str4)
 printf("str3 and str4 are same\n");
    else
 printf("str3 and str4 are not same\n");
       
    return 0;
}

在这里插入图片描述
首先str1和str2都是char型的数组，而不同的数组开辟出来，即使存放的数据一模一样，也是两个数组，既然是两个数组那么首地址（数组名代表首地址）肯定是不同的。
而对于str3和str4，C/C++会把常量字符串存储到单独的一个内存区域，当
几个指针。指向同一个字符串的时候，他们实际会指向同一块内存。但是用相同的常量字符串去初始化
不同的数组的时候就会开辟出不同的内存块。

指针数组

指针数组，顾名思义就是一个数组里面存放的元素全是指针型的。

int* arr1[10];//整形指针的数组，存放了10个整形指针
char *arr2[4]; //一级字符指针的数组
char **arr3[5];//二级字符指针的数组

数组指针

数组指针的定义

数组指针是指针？还是数组？
答案是：指针。
我们已经熟悉：
整形指针： int * pint; 能够指向整形数据的指针。
浮点型指针： float * pf; 能够指向浮点型数据的指针。
那数组指针应该是：能够指向数组的指针。
下面代码哪个是数组指针？

int *p1[10];
int (*p2)[10];
//p1, p2分别是什么？
int (*p)[10];
//解释：p先和*结合，说明p是一个指针变量，然后指着指向的是一个大小为10个整型的数组。所以p是一个
指针，指向一个数组，叫数组指针。
//这里要注意：[]的优先级要高于*号的，所以必须加上（）来保证p先和*结合。

&数组名与数组名

对于一个数组：

int arr[10];

&arr和arr有什么区别呢？
arr代表数组名也就是数组首元素的地址，而&arr代表的是数组的地址，两者的值是相同的，但代表的含义是不同的。我们来看这样一段代码。

#include <stdio.h>
int main()
{
 int arr[10] = { 0 };
 printf("arr = %p\n", arr);
 printf("&arr= %p\n", &arr);
 printf("arr+1 = %p\n", arr+1);
 printf("&arr+1= %p\n", &arr+1);
 return 0;
}

在这里插入图片描述
arr和&arr确实是相同的，但他们代表的含义不同，如果对于两者都进行+1操作，那么arr+1，代表的是arr数组中的第二个元素的地址，但对于&arr+1来说，代表的是直接跳过该数组的下一个地址。所以对于arr+1与&arr+1两者的差值是40，也就是整个arr数组的字节大小。

数组指针的使用

一个数组指针的使用：

#include <stdio.h>
void print_arr1(int arr[3][5], int row, int col)
{
	int i = 0;
	int j = 0;
	for (i = 0; i < row; i++)
	{
		for (j = 0; j < col; j++)
		{
			printf("%d ", arr[i][j]);
		}
			printf("\n");
	}
}
void print_arr2(int(*arr)[5], int row, int col)
{
	int i = 0;
	int j = 0;
	for (i = 0; i < row; i++)
	{
		for (j = 0; j < col; j++)
		{
			printf("%d ", arr[i][j]);
		}
		printf("\n");
	}
}
int main()
{
	int arr[3][5] = { 1,2,3,4,5,6,7,8,9,10 };
	print_arr1(arr, 3, 5);
	//数组名arr，表示首元素的地址
	//但是二维数组的首元素是二维数组的第一行
	//所以这里传递的arr，其实相当于第一行的地址，是一维数组的地址
	//可以数组指针来接收
	print_arr2(arr, 3, 5);
	return 0;
}

这样就是一个使用数组指针的方法。

既然我们已经了解过了，来看一下这些代码的含义：

int arr[5];//一个数组存放的是整形元素
int *parr1[10];//一个指针数组，存放的是整形指针
int (*parr2)[10];//一个数组指针，指向的是数组的指针
int (*parr3[10])[5];//一个包含 10 个指针的数组，每个指针指向一个包含 5 个整数的数组

函数指针

在C语言中，函数指针是指向函数的指针变量。它可以用来存储和访问函数的地址，从而可以通过函数指针调用相应的函数。
我们先来看一段代码：

#include <stdio.h>
void test()
{
 printf("hehe\n");
}
int main()
{
 printf("%p\n", test);
 printf("%p\n", &test);
 return 0;
}

在这里插入图片描述

两个都是test函数的地址，想要将test的地址保存到指针里，我们可以这样做：

void test()
{
	printf("hehe\n");
}
int main()
{
	printf("%p\n", test);
	printf("%p\n", &test);
	void (*pfun)() = test;
	printf("%p\n", pfun);
	return 0;
}

在这里插入图片描述
这样就成功的将test函数地址存到了指针中去。

利用函数指针数组实现简易计算器

相信大家都能够写出一个计算器，所以我们来用函数指针数组来实现一下。

#include<stdio.h>
int add(int a, int b)
{
	return a + b;
}
int sub(int a, int b)
{
	return a - b;
}
int mul(int a, int b)
{
	return a * b;
}
int div(int a, int b)
{
	return a / b;
}
int main()
{
	printf("*********************\n");
	printf("**1.add*******2.sub**\n");
	printf("**3.mul*******4.div**\n");
	printf("*******0.exit********\n");
	int x, y;
	int input = 1;
	int (*p[5])(int, int) = { 0,add,sub,mul,div };
	int ret = 0;
	do
	{
		printf("请选择操作：");
		scanf("%d", &input);
		if (0 < input && input < 5)
		{
			printf("请输入操作数：");
			scanf("%d %d", &x, &y);
			ret = (*p[input])(x, y);
			printf("%d\n", ret);
		}
		else if (input == 0)
		{
			printf("退出程序");
		}
		else
		{
			printf("输入有误，重新选择");
		}
	} while (input);
	return 0;
}

我们首先将加减乘除四个功能分别封装为四个函数，然后将四个函数的地址，存放到指针p中，为了更好的对应，我们把第一个元素设置为0，之后进入循环，将input作为操作数传参给p指针数组的下标，x和y作为操作数传参给对应的函数将返回值赋给ret，最后打印ret即可得到结果。

指针和数组题测试

我们了解了之后，来看一下我们掌握的怎么样

//一维数组
int a[] = {1,2,3,4};
printf("%d\n",sizeof(a));// 16，数组名单独放到sizeof代表的是整个数组的大小，16个字节
printf("%d\n",sizeof(a+0));// 4/8 并非是单独放到sizeof中所以代表的是数组首元素的地址
printf("%d\n",sizeof(*a));//4，*a代表对首元素地址解引用，也就是1这个数字也就是4byte//*a == *(a+0) == a[0]
printf("%d\n",sizeof(a+1));// 4/8代表数组中第二个元素的地址
printf("%d\n",sizeof(a[1]));// 4代表数组中第二个元素
printf("%d\n",sizeof(&a));// 4/8 &a代表a数组的地址，地址的字节是4/8
printf("%d\n",sizeof(*&a));// 16 &a得到数组的地址，后解引用访问整个数组的大小，所以是16
printf("%d\n",sizeof(&a+1));//4/8 &a得到的是地址，+1还是地址所以是4/8
printf("%d\n",sizeof(&a[0]));//4/8 a[0]是首元素，&得到地址所以是4/8
printf("%d\n",sizeof(&a[0]+1));//4/8 得到地址后+1还是地址
//字符数组
char arr[] = {'a','b','c','d','e','f'};
printf("%d\n", sizeof(arr));//6 数组名arr单独放在sizeof内部，计算的是整个数组的大小，单位是字节
printf("%d\n", sizeof(arr+0));//4/8 arr是首元素的地址==&arr[0]，是地址就是4/8个字节
printf("%d\n", sizeof(*arr));//1 arr是首元素的地址，*arr就是首元素，大小就是1Byte
printf("%d\n", sizeof(arr[1]));//1 数组中第二个元素
printf("%d\n", sizeof(&arr));//4/8 整个数组的地址
printf("%d\n", sizeof(&arr+1));//4/8 整个数组地址+1
printf("%d\n", sizeof(&arr[0]+1));//4/8 数组第一个元素的地址+1，第二个元素的地址
printf("%d\n", strlen(arr));//随机值，arr是首元素的地址
printf("%d\n", strlen(arr+0));//随机值，arr是首元素的地址, arr+0还是首元素的地址
printf("%d\n", strlen(*arr));//err，arr是首元素的地址, *arr就是首元素 - 'a' - 97
printf("%d\n", strlen(arr[1]));//err, 'b' - 98
printf("%d\n", strlen(&arr));//随机值 地址
printf("%d\n", strlen(&arr+1));//随机值 地址
printf("%d\n", strlen(&arr[0]+1));//随机值 地址
char arr[] = "abcdef";
printf("%d\n", sizeof(arr));//7 整个数组的大小包括'\0'
printf("%d\n", sizeof(arr+0));//4/8 首元素地址
printf("%d\n", sizeof(*arr));//1 访问数组首元素
printf("%d\n", sizeof(arr[1]));//1 数组中第二个元素
printf("%d\n", sizeof(&arr));//4/8 地址
printf("%d\n", sizeof(&arr+1));//4/8 地址
printf("%d\n", sizeof(&arr[0]+1));//4/8 地址
printf("%d\n", strlen(arr));//6 数组的长度，不包括'\0'
printf("%d\n", strlen(arr+0));//6 arr + 0 的类型是指向字符串的指针，strlen(arr + 0) 返回指针指向的字符串的长度，不包括终止符 \0
printf("%d\n", strlen(*arr));//err 
printf("%d\n", strlen(arr[1]));//err
printf("%d\n", strlen(&arr));//随机值 地址
printf("%d\n", strlen(&arr+1));//随机值 地址
printf("%d\n", strlen(&arr[0]+1));//随机值 地址
char *p = "abcdef";
printf("%d\n", sizeof(p));//4/8 地址
printf("%d\n", sizeof(p+1));//4/8 地址
printf("%d\n", sizeof(*p));//1 代表a
printf("%d\n", sizeof(p[0]));//1 代表a
printf("%d\n", sizeof(&p));//4/8 地址
printf("%d\n", sizeof(&p+1));//4/8 地址
printf("%d\n", sizeof(&p[0]+1));//4/8 地址
printf("%d\n", strlen(p));//随机值 地址
printf("%d\n", strlen(p+1));//随机值 地址
printf("%d\n", strlen(*p));//err
printf("%d\n", strlen(p[0]));//err
printf("%d\n", strlen(&p));//随机值 地址
printf("%d\n", strlen(&p+1));//随机值 地址
printf("%d\n", strlen(&p[0]+1));//随机值 地址
//二维数组
int a[3][4] = {0};
printf("%d\n",sizeof(a));//48 整个数组的大小，4*12=48
printf("%d\n",sizeof(a[0][0]));//4 首行数组的首元素
printf("%d\n",sizeof(a[0]));//16 首行数组
printf("%d\n",sizeof(a[0]+1));//4/8 首行数组地址+1
printf("%d\n",sizeof(*(a[0]+1)));//4 第一行第二个元素解引用
printf("%d\n",sizeof(a+1));//4/8 未单独放代表地址，+1还是地址
printf("%d\n",sizeof(*(a+1)));//16 a+1是第二行的地址,*(a+1)就是第二行，计算的就是第二行的大小
printf("%d\n",sizeof(&a[0]+1));//4/8 地址
printf("%d\n",sizeof(*(&a[0]+1)));//16 第二行的大小
printf("%d\n",sizeof(*a));a表示数组首元素的地址，也就是第一行的地址 *a 就是第一行，也就相当于是第一行的数组名 *a--> *(a+0) -- a[0]
printf("%d\n",sizeof(a[3]));//16

总结

数组名的意义：

sizeof(数组名)，这里的数组名表示整个数组，计算的是整个数组的大小。
&数组名，这里的数组名表示整个数组，取出的是整个数组的地址。
除此之外所有的数组名都表示首元素的地址

指针题测试

给大家留一个看起来很复杂的指针测试题，相信大家理解了指针后，一定能轻而易举的写出来

int main()
{
 char *c[] = {"ENTER","NEW","POINT","FIRST"};
 char**cp[] = {c+3,c+2,c+1,c};
 char***cpp = cp;
 printf("%s\n", **++cpp);
 printf("%s\n", *--*++cpp+3);
 printf("%s\n", *cpp[-2]+3);
 printf("%s\n", cpp[-1][-1]+1);
 return 0;
}