指针知识点笔记总结4

指针数组

指针数组是一个存放指针的数组
 

int* arr[3]={1,2,3};
char* arr[]="abc";
char **arr[]={0};  //二级指针数组

数组指针

int (*p)[10]={0};

与指针数组的区别是数组指针加上了（*p），表示说明p是指针。

数组指针的使用：

整形数组，用这个不能一口气打完，只能借助循环
而字符数组可以（看有没有结束标准\0）

数组名arr，表示首元素的地址

但是二维数组的首元素是二维数组的第一行,

所以这里传递的arr，其实相当于第一行的地址，是一维数组的地址//可以数组指针来接收

回顾指针数组和数组指针：

int arr[5]：整形数组，数组是5个元素

int *parr1[10]：指针数组，数组10个元素，每位元素是int*类型的

int (*parr2)[10];parr2是数组指针，该指针指向一个数组，数组是10个元素，每位元素是int类型的

int (*parr3[10])[5];数组指针，parr3是数组，数组有10个元素，数组的每个类型是int（*）[5]的数组指针类型

void test(int *arr)
{}                      

为什么这样可以进行传参呢？

因为，数组名表示首位元素的地址，而这个arr前面10元素都是整形地址，就应该放到一个整形指针里面去

二维数组传参：

void test(int arr[][])

上面代码是错误的，因为二维数组传参，函数形参的设计只能省略第一个[]的数字。

因为对一个二维数组，可以不知道有多少行，但是必须知道一行多少元素
用指针形式表达：

void test(int (*arr)[5])

一级指针传参：

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

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

函数指针数组
数组里面存放的不是函数，而是函数的地址
eg：
int(*pa[5])(const char*)={&my_strlen};
注意是花括号

指向函数指针数组的指针
//函数指针pfun

void (*pfun)(const char*) = test;

//函数指针的数组pfunArr

void (*pfunArr[5])(const char* str);

pfunArr[0] = test;

//指向函数指针数组pfunArr的指针ppfunArr

void (*(*ppfunArr)[10])(const char*) = &pfunAr

回调函数

回调函数就是一个通过函数指针调用的函数。如果你把函数的指针（地址）作为参数传递给另一个函数，当这个指针被用来调用其所指向的函数时，我们就说这是回调函数

qsort 的使用：记得调用#include<stdlib.h>头文件

整体：
void qsort (void* base, size_t num, size_t size,int (*compar)(const void*,const void*))

分解理解：
void qsort (void* base,--待排序的数组的起始地址
            size_t num,--元素的个数
             size_t size,-一个元素的大小
int (*compar)(const void*,const void*))-两个元素的比较函数
                     为什么要弄成void*形式？
                     设置这个bubble函数的时候，不知道未来排序什么类型的数据，所以比较这两个元素 
                      的类型也不知道，所以只能写成这样

#include<stdlib.h>

#include<stdio.h>
int main()
{
	//对数组进行排序
	int arr[10] = {9,8,7,6,5,4,3,2,1,0};
	int sz = sizeof(arr) / sizeof(arr[0]);
	bubble_sort(arr,sz);
	//打印	for (int i = 0; i < sz; i++)
    {
		printf("%d ", arr[i]);
	}
	return 0;
}
//用回调函数的qsort
Comp(const void* e1,const void* e2)
{
	return *(int*)e1 - *(int*)e2;     这是升序，如果降序的话，可以弄成e2-e1
}
int main()
{
	//对数组进行排序
	int arr[10] = { 9,8,7,6,5,4,3,2,1,0 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	qsort(arr, sz, sizeof(arr[0]), Comp);
	//打印
	for (int i = 0; i < sz; i++)
	{
		printf("%d ", arr[i]);

	}
	return 0;
}

qsort结构体使用

//用回调函数的qsort
//结构体
#include<stdlib.h>
#include<stdio.h>
#include<string.h>
struct Stu
{
	int age;
	char name[20];
};
int cmp_stu_by_age(const void* e1,const void *e2)
{                                                       ->是指向age这个结构体变量
	return ((struct Stu*)e1)->age - ((struct Stu*)e2)->age;
}
int cmp_stu_by_name(const void* e1, const void* e2)
{
	return strcmp(((struct Stu*)e1)->name , ((struct Stu*)e2)->name);
          // strcmp 字符的比较符号
}
void Test1()
{
	struct Stu arr[3] = {{ "bai",20 }, { "laoliu",21 }, { "xiao",22 }};
	int sz = sizeof(arr) / sizeof(arr[0]);
	//qsort(arr, sz, sizeof(arr[0]), cmp_stu_by_age);
	qsort(arr, sz, sizeof(arr[0]), cmp_stu_by_name);

}
int main()
{
	Test1();

	return 0;
}

最后，到了每次鸡汤句子：

待你学成归来，定要记得曾几何时，对我许下的承诺

致那个不放弃的自己