指针进阶(字符指针 指针数组 数组指针 数组传参、指针传参 五、函数指针 函数指针数组 指向函数指针数组的指针 回调函数)

文章目录

  • 一、字符指针
  • 二、指针数组
  • 三、数组指针
    • 1.数组指针的定义
    • 2.&数组名vs数组名
    • 3.数组指针的使用
  • 四、数组传参、指针传参
    • 1.一维数组传参
    • 2.二维数组传参
    • 3.一级指针传参
    • 4.二级指针传参
  • 五、函数指针
  • 六、函数指针数组
  • 七、指向函数指针数组的指针
  • 八、回调函数


在初阶指针里我们已经我们已经学习了指针,在初阶指针的基础上我们再深入挖掘一些指针的知识,有字符指针、数组指针、指针数组、数组传参和指针传参、函数指针、函数指针数组、指向函数指针数组的指针、回调函数、指针和数组面试试题的解析。

指针的概念:

1.指针就是个变量,用来存放地址,地址唯一标识一块内存空间。
2.指针的大小是固定的4/8个字节(32位平台/64位平台)
3.指针是有类型,指针的类型决定了指针的±整数的步长,指针解引用操作的时候的权限。
4.指针的运算…
我们继续探讨指针的高级主题。

一、字符指针

字符指针:char*

在c语言中有两种常见的书写形式:
第一种:

int main()
{
	char ch = 'w';
	char* pc = &ch;
	//*说明pc是指针 char告诉我们pc指向的对象ch它的类型是char类型
	//这就是char*定义的一个pc指针变量
	*pc = 'b';//pc找到ch并改变它

	printf("%c\n", ch);
	return 0;
}

字符指针可以存放一个字符的地址
第二种:

int main()
{
	char* p = "abcdef";
	printf("%s\n", p);
	return 0;
}

指针进阶(字符指针 指针数组 数组指针 数组传参、指针传参 五、函数指针 函数指针数组 指向函数指针数组的指针 回调函数)_第1张图片
我们发现打印的结果是abcdef是一个字符串,那么这个地方p里面放的是不是就是字符串?
答案:不是。
指针进阶(字符指针 指针数组 数组指针 数组传参、指针传参 五、函数指针 函数指针数组 指向函数指针数组的指针 回调函数)_第2张图片

int a = 10int b = a+2//a+2的值赋给b,a+2是表达式 表达式的赋值给b
//表达式有值属性和类型属性,
//a+2的值属性就是12,
//因为a是int类型,2也是int类型,所以a+2的类型属性是int。

当我们看到abcdef字符串作为表达式一部分,把字符串abcdef赋给p的时候,把“abcdef”当成一个表达式,这个表达式赋给p的是首字符a的地址。非要把abcdef放到p里面去是放不下的,abcdef已经6个字符了,再加上后面还隐藏的\0,如果放到p里面去,p有可能是
4个字节,1个字符需要1个字节的空间,4个字节是放不了7个字符的,所以绝对不可能是把abcdef放到p里面去,这种写法是把字符串首字符a 的地址赋值给p,因为p里面放的是a的地址,打印字符串的时候给个%s打印字符串,只需要告诉从哪开始就可以了,p里放的是a的地址,它就知道从a后面往后打印,直到遇到\0。

int main()
{
	char* p = "abcdef";
	*p = 'w';
	printf("%s\n", p);
	return 0;
}

如果这个代码在编译器上报警告,其实是把a的地址放到p里是不安全的,abcdef是个常量字符串,意思就是它不能被改,我把起始地址放到p里去,这个p权限就变大了,p没有被修饰,也就是p敢去改abcdef的内容,如果非要强行改,程序就会崩溃,所以报警告其实是很正常的

指针进阶(字符指针 指针数组 数组指针 数组传参、指针传参 五、函数指针 函数指针数组 指向函数指针数组的指针 回调函数)_第3张图片

我们可以在加个const,就是限制了p不能改,之后p = ‘w’这种写法编译器直接判断错误,这样就有效的保护字符串。

int main()
{
	const char* p = "abcdef";
	*p = 'w';
	printf("%s\n", p);
	return 0;
}

指针进阶(字符指针 指针数组 数组指针 数组传参、指针传参 五、函数指针 函数指针数组 指向函数指针数组的指针 回调函数)_第4张图片

一道笔试题:

int main()
{
    const char* p1 = "abcdef";
	const char* p2 = "abcdef";

	char arr1[] = "abcdef";
	char arr2[] = "abcdef";

	if (p1 == p2)
		printf("p1==p2\n");
	else
		printf("p1 != p2");
	if (arr1 == arr2)
		printf("arr1 == arr2");
	else
		printf("arr1 != arr2");

	return 0;
}

结果是:

p1==p2
arr1 != arr2

p1和p2指向同一个字符串,这个字符串是常量字符串,放在内存中的只读区里,只读区的空间只能读不能写,只能用不能改,既然abcdef是常量字符串的话不能被改,那abcdef这样的常量字符串有没有必要存在多份,其实存一份就够了,假设a的起始地址是0x0012ff40,那么p1里存的就是这个值,p2也是这个值,所以p1 == p2,因为它俩里面放的值是相等的,再往下,发现arr1 和 arr2不相等,因为在那里,我们创建的两个独立数组,用abcdef初始化arr1[]数组,arr1[]要放下abcdef\0,就要在内存中开辟一段空间,arr2[]也一样,两块空间的起始地址不一样,arr1和arr2都是起始地址,它俩在内存中的地址绝对是不相等的。

二、指针数组

在初阶我们学习了指针数组,指针数组是一个存放指针的数组,这里我们简单复习下。
指针数组:是数组,是用来存放指针的数组,

int arr[10];//整形数组
char ch[5];//字符数组
//指针数组
int* arr2[6];//这是一个存放整型指针的数组
//arr2数组名,6个元素,数组的每个元素是int*类型的值
//每个元素都是int* 类型的值
char* arr3[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* parr[] = { arr1,arr2,arr3 };

	return 0;
}

arr1相当于1的地址,arr2相当于2的地址,arr3相当于3的地址。arr1 arr2 arr3都是整型的地址,所以parr这个数组应该是int*类型的。

指针进阶(字符指针 指针数组 数组指针 数组传参、指针传参 五、函数指针 函数指针数组 指向函数指针数组的指针 回调函数)_第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* parr[3] = { arr1,arr2,arr3 };

	int i = 0;
	int j = 0;
	for (i = 0; i < 3; i++)
	{
		for (j = 0; j < 5; j++)
		{
			printf("%d ", *(parr[i] + j));//也可以写成parr[i][j]
		}
		printf("\n");
	}
	return 0;
}

打印出来结果:

1 2 3 4 5
2 3 4 5 6
3 4 5 6 7

三、数组指针

1.数组指针的定义

数组指针是指针

类比:

整型指针——指向整型的指针
字符指针——指向字符的指针
数组指针——指向数组的指针

int *p1[10];
int (*p2)[10];
//p1, p2分别是什么?

指针进阶(字符指针 指针数组 数组指针 数组传参、指针传参 五、函数指针 函数指针数组 指向函数指针数组的指针 回调函数)_第6张图片
想要使用数组指针,我们还得先把数组名深入理解一下:

2.&数组名vs数组名

int main()
{
	int arr[10] = { 0 };
	printf("%p\n", arr);
	printf("%p\n", &arr[0]);
	return 0;
}

打印结果:

006FFAD0
006FFAD0
//数组名就是首元素地址
int main()
{
	int arr[10] = { 0 };
	printf("%p\n", arr);
    printf("%p\n", &arr[0]);
	int sz = sizeof(arr);
	printf("%d\n", sz);
	return 0;
}

打印结果:

006FFAD0
006FFAD0
40

当我们这样去写的时候,有的同学就会产生歧义,刚刚我们说了,数组名是首元素地址,如果数组名是首元素地址,首元素地址是地址,所以就是4个字节或者8个字节,那sizeof算出来应该是4 或者 8 ,但是发现结果是40,所以两个地址是一模一样,好像认定了数组名就是首元素地址,但是当我们写sizeof(arr)的时候发现数组名好像不是首元素地址,这个我们要注意:
数组名通常表示的都是数组首元素地址。

但是有两个例外:

1.sizeof(数组名)sizeof里面单独放一个数组名的时候是一个例外,这里的数组名表示整个数组,计算的是整个数组的大小,单位是字节。
2.&数组名,这里的数组名表示的依然是整个数组,所以&数组名,取出的是整个数组的地址。
指针进阶(字符指针 指针数组 数组指针 数组传参、指针传参 五、函数指针 函数指针数组 指向函数指针数组的指针 回调函数)_第7张图片

区别请看下面代码:

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

    printf("%p\n", &arr[0]);
	printf("%p\n", &arr[0]+1);

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

	return 0;
}

打印结果:

00BBFB70
00BBFB74
00BBFB70
00BBFB74
00BBFB70
00BBFB98

我们观察,arr 和arr+1差了4个字节,&arr[0] 和 &arr[0]+1差了4个字节,我们发现首元素地址+1,加了4个字节,因为我们知道这个数组每个元素都是int类型的,因为数组名表示首元素地址的话,这里就是int类型的地址,那arr的类型是int* ,而int*的指针+1跳过四个字节,所以都是相差4。
那&arr 和 &arr + 1 相差40,0x28——>40,&数组名,取出的是整个数组的地址,&arr+1 表示跳过整个数组。

整形指针是用来存放整型的地址
字符指针用来存放字符的地址
数组指针用来存放数组的地址

int main()
{
	int arr[10] = { 0 };
	int* p = arr;
	int (*p2)[10] = &arr;//数组指针
	return 0;
}

3.数组指针的使用

int main()
{
	int arr[] = { 1,2,3,4,5,6,7,8,9,10 };
	int(*p)[] = &arr;//这样写是不行的
	return 0;
}

指针进阶(字符指针 指针数组 数组指针 数组传参、指针传参 五、函数指针 函数指针数组 指向函数指针数组的指针 回调函数)_第8张图片
warning : “int ( * )[0]”和“int ( * )[10]”数组的下标不同,int(*)[ ]认为 [ ]里面是0,两个对不上,所以必须写清楚几个元素,不能省略10!

int main()
{
	int arr[] = { 1,2,3,4,5,6,7,8,9,10 };
	int(*p)[10] = &arr;

	int i = 0;
	int sz = sizeof(arr) / sizeof(arr[0]);
	for (i = 0; i < sz; i++)
	{
		printf("%d ", *(*p+i));

	}
	return 0;
}
	p是指向数组的,*p其实就相当于数组名
	数组名,又是数组首元素的地址,所以*p本质上数组首元素地址

打印结果:

1 2 3 4 5 6 7 8 9 10

我们发现这种用法非常的别扭,这种用方法很不好,下面我们看看正常的写法:

int main()
{
	int arr[] = { 1,2,3,4,5,6,7,8,9,10 };
	int* p = arr;
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		printf("%d ", *(p + i));
	}
	return 0;
}

这种写法就很容易让人理解。

数组指针多用在 二维三维数组里
用数组指针写的话

大概思路:

指针进阶(字符指针 指针数组 数组指针 数组传参、指针传参 五、函数指针 函数指针数组 指向函数指针数组的指针 回调函数)_第9张图片

//用数组传参实现:
void print1(int arr[3][5], int r, int c)
{
	int i = 0;
	for (i = 0; i < r; i++)
	{
		int j = 0;
		for (j = 0; j < c; j++)
		{
			printf("%d ",arr[i][j]);

		}
		printf("\n");
	}
}
int main()
{
	int arr[3][5] = { 1,2,3,4,5,2,3,4,5,6,3,4,5,6,7 };
	print1(arr,3,5);
	return 0;
}
//数组指针的写法:
void print2(int(*p)[5], int r, int c)
{
	int i = 0;
	for (i = 0; i < r; i++)
	{
		int j = 0;
		for (j = 0; j < c; j++)
		{
			printf("%d ", *(*(p + i) + j));
		}
		printf("\n");
	}
}
int main()
{
	int arr[3][5] = { 1,2,3,4,5,2,3,4,5,6,3,4,5,6,7 };
	print2(arr,3,5);
	return 0;
}

打印结果:

1 2 3 4 5
2 3 4 5 6
3 4 5 6 7

再捋一遍思路:

指针进阶(字符指针 指针数组 数组指针 数组传参、指针传参 五、函数指针 函数指针数组 指向函数指针数组的指针 回调函数)_第10张图片
p我们说指向的是第一行,p+1为什么就跳过一行呢?

当我们有int (* p) [5]这样一个指针的时候,
p的类型是: int (*)[5] ;
p 是指向一个整型数组的,数组是5个元素 int [5]
p+1就是跳过一个5个int元素的数组。

四、数组传参、指针传参

写代码的时候,难免会把【数组】或者【指针】传给函数,那函数的参数该如何设计呢?

1.一维数组传参

一维数组传参

指针进阶(字符指针 指针数组 数组指针 数组传参、指针传参 五、函数指针 函数指针数组 指向函数指针数组的指针 回调函数)_第11张图片

2.二维数组传参

二维数组传参

指针进阶(字符指针 指针数组 数组指针 数组传参、指针传参 五、函数指针 函数指针数组 指向函数指针数组的指针 回调函数)_第12张图片

3.一级指针传参

一级指针传参

指针进阶(字符指针 指针数组 数组指针 数组传参、指针传参 五、函数指针 函数指针数组 指向函数指针数组的指针 回调函数)_第13张图片

4.二级指针传参

二级指针传参

指针进阶(字符指针 指针数组 数组指针 数组传参、指针传参 五、函数指针 函数指针数组 指向函数指针数组的指针 回调函数)_第14张图片

五、函数指针

一般是函数指针和数组指针类比

数组指针—指向数组的指针就是数组指针
函数指针—指向函数的指针就是函数指针

int Add(int x, int y)
{
	return x + y;
}
int main()
{
	//&函数名 - 取出的是不是函数的地址呢?
	printf("%p ", &Add);
	//如果把&Add 换成Add 拿出的结果是一样的
	return 0;
}

打印出的是函数的地址

003410B4

取地址函数名确实拿到的是函数的地址
对函数来说,&函数名和函数名都是函数的地址

如何存函数的地址?有什么应用?

int Add(int x, int y)
{
	return x + y;
}
int main()
{
 	int(*pf)(int,int) = &Add;
	int ret = (*pf)(2, 3);
	printf("%d\n", ret);
	return 0;
}

打印结果

5

这里其实就做到了间接的(通过地址来调用函数)通过函数指着访问函数。

简单的应用:

int Add(int x, int y)
{
	return x + y;
}
void calc(int (*pf)(int,int))
{
	int a = 1;
	int b = 4;
	int ret = pf(a, b);
	printf("%d\n", ret);
}
int main()
{
	calc(Add);
	return 0;
}

输出结果

5

有了函数指针的这样一个东西,我们就可以把函数地址进行传参,传给另外一个函数,这个函数想调用那个函数的时候,就可以通过函数指针调用。

六、函数指针数组

把函数和指针放在数组中就是函数指针数组

#include
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()
{
	int (*pf)(int,int) = Add;//pf是函数指针

	int (*arr[4])(int, int) = {Add, Sub, Mul, Div};//arr就是函数指针的数组

	int i = 0;
	for (i = 0; i < 4; i++)
	{
		int ret = arr[i](8, 4);
		printf("%d \n", ret);
	}
	return 0;
}
12
4
32
2

指针进阶(字符指针 指针数组 数组指针 数组传参、指针传参 五、函数指针 函数指针数组 指向函数指针数组的指针 回调函数)_第15张图片

七、指向函数指针数组的指针

#include
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()
{
	//函数指针数组
	int (*pfArr[])(int, int) = { 0,Add, Sub, Mul, Div };

	//指向【函数指针数组】的指针
	int (*(*ppfArr)[5])(int, int) = &pfArr;

	return 0;
}

八、回调函数

回调函数就是一个通过函数指针调用的函数。如果你把函数的指针(地址)作为参数传递给另一个函数,当这个指针被用来调用其所指向的函数时,我们就说这是回调函数。回调函数不是由该函数的实现方直接调用,而是在特定的事件或条件发生时由另外的一方调用的,用于对该事件或条件进
行响应。

实例:冒泡排序
指针进阶(字符指针 指针数组 数组指针 数组传参、指针传参 五、函数指针 函数指针数组 指向函数指针数组的指针 回调函数)_第16张图片

void qsort(void* base, //排序的数据的起始位置
	       size_t num,//待排序的数据元素的个数
	       size_t width,//待排序的数据元素的大小(单位是字节)
	       int(* comp)(const void* e1, const void* e2)//函数指针 - 比较函数
           );

//__cdecl - 函数调用约定
int main()
{
	int a = 10;
	//char* pa = &a;//int*
	void* pv = &a;//void* 是无具体类型的指针,可以接受任意类型的地址
	//void* 是无具体类型的指针,所以不能解引用,也不能+-整数
	return 0;
}
int cmp_int(const void* e1, const void* e2)
{
	return (*(int*)e1 - * (int*)e2);
}
int main()
{
	int arr[] = { 9,8,7,6,5,4,3,2,1,0 };
	//把数组排成升序
	int sz = sizeof(arr) / sizeof(arr[0]);
	/*bubble_sort(arr, sz);*/
	qsort(arr, sz, sizeof(arr[0]),cmp_int );
	int i = 0;
	for (i = 0; i < sz; i++)
	{
		printf("%d ",arr[i]);
	}
	return 0;

}
0 1 2 3 4 5 6 7 8 9

你可能感兴趣的:(C语言,c++,开发语言)