指针进阶(三) (跑路人笔记)

前言

十分抱歉咕了这么久,郑州这几天实在太冷了.后天应该会有(四)绝对不咕.

一维数组传参

#include
void test(int arr[])//√ 可以 其实在函数接收时并不会创建一个数组他其实本质上就只是指针
{} 
void test(int arr[10])//√ 可以
{}
void test(int *arr)//√ 可以
{}
void test2(int *arr[20])//√ 可以 和传参类型相同
{}
void test2(int **arr)//√ 可以 传来的是一维指针数组 arr2是首元素的内存相当于指针的内 
                     //存是传来的参数我们用二级指针接收也是完全可以的
{}
int main() 
{ 
	int arr[10] = {0};//普通的整形数组
	int *arr2[20] = {0};//普通的整形指针数组
	test(arr);
	test2(arr2);
}

二维数组传参

void test(int arr[3][5])//√ 可以 和传参一样当然就没啥说的
{} 
void test(int arr[][])//× 我们在建立二维数组时只能忽略第一个数字不能忽略第二个数字
                      //  因为我们必须知道他一行有几个元素也就是一行有几列.
{} 
void test(int arr[][5])//√ 可以 原因与上面类似
{} 
//总结：二维数组传参，函数形参的设计只能省略第一个[]的数字。
//因为对一个二维数组，可以不知道有多少行，但是必须知道一行多少元素。
//这样才方便运算。 
void test(int *arr)// ×  类型不同
{}
void test(int* arr[5])// × 类型不同
{}
void test(int (*arr)[5])// √ 可以 作为一个指向五行数组的数组指针可以
{} 
void test(int **arr)//× 不行
{} 
int main()
{ 
	int arr[3][5] = {0};
	test(arr); 
}

对
void test(int *arr)// × 类型不同 {}
的解释

函数指针的知识点

回调函数

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

qosrt使用了回调函数我们从中窥探一下

qosrt函数 (引入void *类型指针)

(void在排列函数及下一个小标题)
qosrt可以对你传入的数组(数组包括-整形,字符,结构体等)进行快速排序
注:本次只对int类型的数组进行排序
使用时也并不难,我们先演示如何使用qosrt函数

//qosrt函数的使用者得实现一个比较函数
int int_cmp(const void * p1, const void * p2) 
{ 
	return (*( int *)p1 - *(int *) p2);
} 
int main() 
{  
	int arr[] = { 1, 3, 5, 7, 9, 2, 4, 6, 8, 0 };
	int i = 0;
	qsort(arr, sizeof(arr) / sizeof(arr[0]), sizeof (int), int_cmp);
	for (i = 0; i< sizeof(arr) / sizeof(arr[0]); i++)
	{
		printf( "%d ", arr[i]);
	} 
	printf("\n");
	return 0; 
}

qosrt(要排列的数组 , 数组元素个数 , 数组类型大小(int 就是4) , 排列函数(自己创建))

排列函数

int int_cmp(const void * p1, const void * p2) 
{ 
	return (*( int *)p1 - *(int *) p2);
} 

void*类型可以接收任意的指针类型但是在使用时我们必须要将其强制类型转换成我们想要的元素才可以进行使用
我们的排列函数按照先p1后p2时我们的qsort函数就回家将数组里的数字从小到大进行排列当我们想倒序时我们可以将return中的p1和p2交换位置即可.

模拟实现qsort函数(使用冒泡排序)

不妨先看一下真正的qsort函数的声明

size_t的意思是unsigned int 不过使用size_t可以提高兼容度

我们看一下我们代码的所有部分再拆开进行讲解

int cmp(const void* p1, const void* p2)
{
	return *(int*)p1 - *(int*)p2;
}
void swap (void* p1, void* p2, size_t size)
{
	for (int i = 0; i < size; i++)
	{
		char tmp = *((char*)p1 + i);
		*((char*)p1 + i) = *((char*)p2 + i);
		*((char*)p2 + i) = tmp;
	}

}
void qsort_bubble(void* base,
				size_t count, size_t size,
				int (*cmp)(const void* p1, const void* p2))
{
	int i = 0;
	int j = 0;
	for (i = 0; i < count - 1; i++)
	{
		for (j = 0; j < count - 1 - i; j++)
		{
			if (cmp((char*)base + j * size, (char*)base + (j + 1) * size)>0)
			{
				swap((char*)base + j * size, (char*)base + (j + 1) * size,size);
			}
		}

	}
}
int main(void)
{
	int arr[10] = { 0,2,3,1,4,5,6,7,9,8 };
	//qsort(arr, sizeof(arr) / sizeof(arr[0]), sizeof(int), cmp);
	qsort_bubble(arr, sizeof(arr) / sizeof(arr[0]), sizeof(int), cmp);//要实现的函数
	return 0;
}

为了方便我们将交换部分单独创建一个函数
难点在拆解讲解讲解

拆解讲解

我们类比这qsort函数类比进行创建:

冒泡排序部分:
应该不用讲吧…
后续等俺学会了快速排序也更上去.
交换部分函数:

void swap (void* p1, void* p2, size_t size)
{
	for (int i = 0; i < size; i++)
	{
		char tmp = *((char*)p1 + i);
		*((char*)p1 + i) = *((char*)p2 + i);
		*((char*)p2 + i) = tmp;
	}
}

注意我们在对指针p1强制类型转换的时候是将它转换成了char* 类型并且我们的循环次数和我们传来的类型大小相同 这样设置的原因是可以适应一切类型的传参 因为我们是对它内存中一个一个字节进行操作的.

重新讲回回调函数

我们回调函数就是将函数通过传参的方式传入,然后通过函数指针进行调用qsort就是使用了回调函数,通过函数指针调用的函数就被称为回调函数.