指针的进阶

最新推荐文章于 2023-06-17 23:53:09 发布

apple_64351502

最新推荐文章于 2023-06-17 23:53:09 发布

阅读量50

点赞数

文章标签：面试 c++ 职场和发展

本文链接：https://blog.csdn.net/apple_64351502/article/details/127106775

版权

BIT-2-指针的进阶
本章重点

字符指针
数组指针
指针数组
数组传参和指针传参
函数指针
函数指针数组
指向函数指针数组的指针
回调函数
指针和数组面试题的解析

指针的主题，我们在初级阶段的《指针》章节已经接触过了，我们知道了指针的概念：
10. 指针就是个变量，用来存放地址，地址唯一标识一块内存空间。
11. 指针的大小是固定的4/8个字节（32位平台/64位平台）。
12. 指针是有类型，指针的类型决定了指针的±整数的步长，指针解引用操作的时候的权限。
13. 指针的运算。
#1. 字符指针
在指针的类型中我们知道有一种指针类型为字符指针 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;
}

代码 const char* pstr = “hello bit.”;特别容易让同学以为是把字符串 hello bit 放到字符指针 pstr 里了，但是/本质是把字符串 hello
bit. 首字符的地址放到了pstr中。

在这里插入图片描述

上面代码的意思是把一个常量字符串的首字符 h 的地址存放到指针变量 pstr 中。

那就有可这样的面试题：

#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;
}

这里最终输出的是
在这里插入图片描述

这里str3和str4指向的是一个同一个常量字符串。C/C++会把常量字符串存储到单独的一个内存区域，当
几个指针。指向同一个字符串的时候，他们实际会指向同一块内存。但是用相同的常量字符串去初始化
不同的数组的时候就会开辟出不同的内存块。所以str1和str2不同，str3和str4不同。
如果要比较字符串内容使用：strcmp
例：

在这里插入图片描述

	int arr1[5] = { 1,2,3,4,5 };
	int arr2[5] = { 2,3,4,5,6 };
	int arr3[5] = { 3,4,5,6,7 };

	int* arr[3] = {arr1, arr2, arr3};

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

在这里插入图片描述

#2. 指针数组
在《指针》章节我们也学了指针数组，指针数组是一个存放指针的数组。
这里我们再复习一下，下面指针数组是什么意思？
在这里插入图片描述
#3. 数组指针
##3.1 数组指针的定义
数组指针是指针？还是数组？
答案是：指针。
我们已经熟悉：
整形指针： int * pint; 能够指向整形数据的指针。
浮点型指针： float * pf; 能够指向浮点型数据的指针。
那数组指针应该是：能够指向数组的指针。

//整型指针 - 指向整型的指针  - 存放整型变量的地址
//int* p1;
//int a=10;
//int* p1=&a;
//字符指针 - 指向字符的指针  - 存放字符变量的地址
//char* p2;
//char ch='w';
//char* p2=&ch;
//数组指针 - 指向数组的指针  - 存放的是数组的地址
//int arr[10]=&arr;//取出的是数组的地址存放到pa中，pa是数组指针的变量
//int（*）->数组指针类型

##3.2 &数组名VS数组名
对于下面的数组：

int arr[10];

arr 和 &arr 分别是啥？
我们知道arr是数组名，数组名表示数组首元素的地址。
那&arr数组名到底是啥？

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

在这里插入图片描述
可见数组名和&数组名打印的地址是一样的。
难道两个是一样的吗？
我们再看一段代码：

#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，虽然值是一样的，但是意义应该不一样的。
实际上： &arr 表示的是数组的地址，而不是数组首元素的地址。（细细体会一下）
本例中 &arr 的类型是： int(*)[10] ，是一种数组指针类型
数组的地址+1，跳过整个数组的大小，所以 &arr+1 相对于 &arr 的差值是40.
数组名是数组首元素的地址
有2个例外：
1.sizeof（数组名）
2.&数组名
##3.3 数组指针的使用
那数组指针是怎么使用的呢？
既然数组指针指向的是数组，那数组指针中存放的应该是数组的地址。
看代码：

#include <stdio.h>
int main()
{
    int arr[10] = {1,2,3,4,5,6,7,8,9,0};
    int (*p)[10] = &arr;//把数组arr的地址赋值给数组指针变量p
    //但是我们一般很少这样写代码
    return 0;
}

一个数组指针的使用：

#include <stdio.h>
void print_arr1(int arr[3][5], int row, int col)
{
    int i = 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;
    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;
}

在这里插入图片描述

#4. 数组参数、指针参数
在写代码的时候难免要把【数组】或者【指针】传给函数，那函数的参数该如何设计呢？
##4.1 一维数组传参
在这里插入图片描述
##4.2二维数组传参

##4.3 一级指针传参

##4.4 二级指针传参

#5. 函数指针
首先看一段代码：

int Add(int x, int y)
{
	return x + y;
}
int main()
{
	pf就是函数指针变量
	int (*pf)(int x, int y) = &Add;
	int (* pf)(int x, int y) = Add;
	int sum = (*pf)(3, 5);
	int sum = Add(3, 5);

	printf("%d\n", sum);

	int arr[10] = {0};
	int (*p)[10] = &arr;
	printf("%p\n", &arr);//取出数组的地址 整个数组地址
	printf("%p\n", arr);//取出数组的地址 首字母地址

	Add 和 &Add都是函数的地址，没有区别
	printf("%p\n", Add);
	printf("%p\n", &Add);

	

	return 0;
}

函数指针

int test(const char* str, double d)
{

}

int main()
{
	int (*pt)(const char*, double) = &test;
	int (*pt)(const char* str, double d) = &test;

	return 0;
}

阅读两段有趣的代码：

//代码1
(*(void (*)())0)();
//代码2
void (*signal(int , void(*)(int)))(int);

解：

int main()
{
	//0 - int
	//( void (*)() )0 - 把0当做一个函数的地址
	//
	//( *( void (*)() )0 )();
	//
	//把0直接转换成一个void (*)()的函数指针，然后去调用0地址处的函数
	//int float
	void(*signal(int, void(*)(int)))(int);

	typedef void(*pf_t)(int) ;//pf_t=void(*)(int)
	pf_t signal( int, pf_t);

	//
	//上述代码是一次函数声明
	//声明的函数叫：signal
	//signal函数的第一个参数是int类型的
	//signal函数的第二个参数是一个函数指针类型，该函数指针指向的函数参数是int，返回类型是void
	//signal函数的返回类型也是一个函数指针类型，该函数指针指向的函数参数是int，返回类型是void
	//void (*)(int) signal(int, void(*)(int)); //err

	return 0;
}

#6. 函数指针数组

int main()
{
	//函数指针数组
	//可以存放多个【参数相同、返回类型相同】的函数的地址
	int (* pfArr[2])(int, int) = {Add, Sub};
	
	int ret = pfArr[0](2, 3);
	printf("%d\n", ret);
	
	ret = pfArr[1](2, 3);
	printf("%d\n", ret);

	return 0;
}

写一个计算器

写一个计算器
整数的加、减、乘、除


int Add(int x, int y)
{
	return x + y;
}

int Sub(int x, int y)
{
	return x - y;
}

int Mul(int x, int y)
{
	return x * y;
}

int Div(int x, int y)
{
	return x / y;
}


void menu()
{
	printf("***************************\n");
	printf("***** 1.add    2. sub  ****\n");
	printf("***** 3.mul    4. div  ****\n");
	printf("***** 0.exit           ****\n");
	printf("***************************\n");
}

int main()
{
	int input = 0;
	int x = 0;
	int y = 0;
	int ret = 0;
	do
	{
		menu();
		printf("请选择:>");
		scanf("%d", &input);
		
		switch (input)
		{
		case 1:
			printf("请输入2个操作数:>");
			scanf("%d %d", &x, &y);
			ret = Add(x, y);
			printf("%d\n", ret);
			break;
		case 2:	
			printf("请输入2个操作数:>");
			scanf("%d %d", &x, &y);
			ret = Sub(x, y);
			printf("%d\n", ret);
			break;
		case 3:
			printf("请输入2个操作数:>");
			scanf("%d %d", &x, &y);
			ret = Mul(x, y);
			printf("%d\n", ret);
			break;
		case 4:
			printf("请输入2个操作数:>");
			scanf("%d %d", &x, &y);
			ret = Div(x, y);
			printf("%d\n", ret);
			break;
		case 0:
			printf("退出计算器\n");
			break;
		default:
			printf("选择错误\n");
			break;
		}
	} while (input);

简化：

int Add(int x, int y)
{
	return x + y;
}

int Sub(int x, int y)
{
	return x - y;
}

int Mul(int x, int y)
{
	return x * y;
}

int Div(int x, int y)
{
	return x / y;
}


void menu()
{
	printf("***************************\n");
	printf("***** 1.add    2. sub  ****\n");
	printf("***** 3.mul    4. div  ****\n");
	printf("***** 0.exit           ****\n");
	printf("***************************\n");
}

int main()
{
	int input = 0;
	int x = 0;
	int y = 0;
	int ret = 0;

	//函数指针数组   - 转移表
	int (*pfArr[])(int, int) = { 0, Add, Sub, Mul, Div };

	do
	{
		menu();
		printf("请选择:>");
		scanf("%d", &input);
		if (input == 0)
		{
			printf("退出计算器\n");
			break;
		}

		if (input >= 1 && input <= 4)
		{
			printf("请输入2个操作数:>");
			scanf("%d %d", &x, &y);
			ret = pfArr[input](x, y);
			printf("%d\n", ret);
		}
		else
		{
			printf("选择错误\n");
		}	
	} while (input);
}

#7. 指向函数指针数组的指针
指向函数指针数组的指针是一个指针
指针指向一个数组，数组的元素都是函数指针 ;
如何定义？

void test(const char* str)
{
 printf("%s\n", str);
}
int main()
{
 //函数指针pfun
 void (*pfun)(const char*) = test;
 //函数指针的数组pfunArr
 void (*pfunArr[5])(const char* str);
 pfunArr[0] = test;
 //指向函数指针数组pfunArr的指针ppfunArr
 void (*(*ppfunArr)[5])(const char*) = &pfunArr;
 return 0;
}

在这里插入图片描述

apple_64351502

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
指针的进阶

不同的数组的时候就会开辟出不同的内存块。数组的地址+1，跳过整个数组的大小，所以 &arr+1 相对于 &arr 的差值是40.12. 指针是有类型，指针的类型决定了指针的±整数的步长，指针解引用操作的时候的权限。根据上面的代码我们发现，其实&arr和arr，虽然值是一样的，但是意义应该不一样的。实际上： &arr 表示的是数组的地址，而不是数组首元素的地址。在《指针》章节我们也学了指针数组，指针数组是一个存放指针的数组。既然数组指针指向的是数组，那数组指针中存放的应该是数组的地址。
复制链接

扫一扫