C语言进阶(2) ---- 指针的进阶

前言：指针的主题，我们在初阶的《指针》章节已经接触过了，我们知道了指针的概念：

1.指针就是个变量，用来存放地址，地址唯一标识一块内存空间。

2.指针的大小是固定的4/8个字节(32位平台/64位平台)。

3.指针是有类型的，指针的类型决定了指针的+-整数的步长，指针解引用操作的时候的权限。

4.指针的运算。

目录

[1. 字符指针](#1. 字符指针)

2.指针数组

[3. 数组指针](#3. 数组指针)

[3.1 数组指针的定义](#3.1 数组指针的定义)

[3.2 &数组名VS数组名](#3.2 &数组名VS数组名)

[3.3 数组指针的使用](#3.3 数组指针的使用)

[4. 数组参数、指针参数](#4. 数组参数、指针参数)

[4.1 一维数组传参](#4.1 一维数组传参)

[4.2 二维数组传参](#4.2 二维数组传参)

[4.3 一级指针传参](#4.3 一级指针传参)

[4.4 二级指针传参](#4.4 二级指针传参)

[5. 函数指针](#5. 函数指针)

[6. 函数指针数组](#6. 函数指针数组)

[7. 指向函数指针数组的指针](#7. 指向函数指针数组的指针)

[8. 回调函数](#8. 回调函数)

8.1.冒泡排序

8.2.qsort函数

8.3.用qsort来改正冒泡排序

---

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 O
{
    char str1[] = "hell o bit.";
    char str2[] = "hello bit.";
    const char *str3 = "hell o bit.";
    const char *str4 = "hello bit.";
    if(str1 == str2)
        printf("strl 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相同。

2.指针数组

在《指针》章节我们也学了指针数组，指针数组是一个存放指针的数组。
这里我们再复习一下，下面指针数组是什么意思？

1. int* arr1 [ 10 ]; // 整形指针的数组
2. char * arr2 [ 4 ]; // 一级字符指针的数组
3. char ** arr3 [ 5 ]; // 二级字符指针的数组
   重要：

整形数组 - 存放整形的数组

字符数组 - 存放字符的数组

指针数组 - 存放指针的数组

数组指针 - 指向数组的指针。

3. 数组指针

3.1 数组指针的定义

数组指针是指针？还是数组？

答案是：指针。 （指向数组的指针）

整型指针： int* pint; 能够指向整形数据的指针。

浮点型指针：float* pf; 能够指向浮点型数据的指针。

那数组指针应该是：能够指向数组的指针。
下面代码哪个是数组指针？

int * p1 [ 10 ];
>>p1 -> 是一个指针数组，存放的是指针数组，存放类型为int* .
int ( * p2 )[ 10 ];
>>p2 -> 是一种数组指针，存放的是数组指针，存放元素类型int。
//p1, p2 分别是什么？
p1存放的是第一个元素的地址，
p1+1 - 跳过一个int ，
*p 访问一个int数据4个字节。
p2存放的是arr数组的地址，
p2+1 - 跳过了整个数组，
*p2访问到的是arr数组，*p2等价于arr了，那么*p2就是数组名了，数组名有相当于首元素的地址，所以*p2本质上是arr数组第一个元素的地址。
解释：
int ( * p )[ 10 ];
//解释：p先和*结合，说明p是一个指针变量，然后指着指向的是一个大小为10个整型的数组。所以p是一个指针，指向一个数组，叫数组指针。
//这里要注意：[]的优先级要高于*号的，所以必须加上（）来保证p先和*结合。

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.
//数组的地址存起来，就应该放在数组指针中!

int (*p)[10] = &arr;

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

学习了指针数组和数组指针，解读下下面代码的意思：

int arr [ 5 ];
arr 是一个整型数组，5个元素，每个元素类型为int。
int * parr1 [ 10 ];
parr1 是一个数组，有10个元素，每个元素的类型是 int* ,所以parr1是指针数组。
int ( * parr2 )[ 10 ];
parr2 和 * 结合，说明parr2是一个指针，该指针指向一个数组，数组是10个元素，每个元素是int类型的。所以 parr2是数组指针。
int ( * parr3 [ 10 ])[ 5 ];
parr3 和 [] 结合，说明parr3是一个数组，数组是10个元素，数组的每个元素是什么类型呢？
是一种数组指针，类型是int(*)[5] . 该类型的指针指向有5个int 类型的元素。
（[ ] 优先级高于 * ）
那怎么打印数组呢，根据之前学的内容：

int main()
{
	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
	//最简单的方法，*(p + i)，直接首元素地址去打印，然后加一，往后跳去打印
	int*p = arr;
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		printf("%d ", *(p + i));
	}
	return 0;
}

当用数组指针来写的话：

    //用数组指针， 这样不如下面用首元素的地址往后跳，找到数组的地址，然后用下标
	int (* p)[10] = &arr;
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		printf("%d ", (*p)[i]);
	}

但是有点大材小用了，我们再来看二维数组中的使用，会不会比以前的方法变的简单呢

void print1(int arr[3][4], int row, int col)
{
	int i = 0;
	for (i = 0; i < row; i++)
	{
		int j = 0;
		for (j = 0; j < col; j++)
		{
			printf("%d ", arr[i][j]);
			//i行j列去打印，二维数组的普通打印用下标
		}
		printf("\n");
	}
}

我们用数组指针来写

void print2(int(*p)[4], int row, int col)
{
	int i = 0;
	for (i = 0; i < row; i++)
	{
		int j = 0;
		for (j = 0; j < col; j++)
		{			
			printf("%d ", (*(p + i))[j]);
//先拿到数组指针找到这个数组，p是指针哪一行的，加i就是找到所有的行，然后再加上一个下标
		}
		printf("\n");
	}
}

打印的时候还有一种写法

printf("%d ", p[i][j]);

//这样写也是可以的，直接找到整个数组第一行地址，然后往后下一行，每一行的下标j，找到所有元素

**4.**数组参数、指针参数

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

4.1****一维数组传参

数组传参的时候，形参写成数组形式。--- ok

#include<stdio.h>
 
void test1()//如何传参数？
 
void test2()//如何传参数？
 
int main()
{
	int arr1[10] = { 0 };
	int* arr2[20] = { 0 };
	test1(arr1);
	test2(arr2);
}

参数可以这样写：

#include <stdio.h>

void test(int arr[])//ok? //ok 可以传参

{}//函数中arr传来，数组传参，参数的部分写为数组

void test(int arr[10])//ok? //ok

{}//函数中arr传来，数组传参，参数的部分写为数组，定义个大小也是可以的

void test(int *arr)//ok? //ok

{}//函数中arr传来，是首元素地址，每个元素都整型，数组传参，也可以用指针接受，所有用整型指针来接收

void test2(int *arr[20])//ok? //ok

{}//函数中arr2传来，是首元素地址，arr2是数组里面放的指针，传来后，用指针数组来接受地址

void test2(int **arr)//ok? //ok

{}//函数中arr2传来，是首元素地址，arr2是数组里面放的指针，形参里面的*arr，就是数组首元素地址解引用，就是数组，所有**arr就可以接收传来的指针

void test2(int* arr)

{}//这样是不行的，传来的数组名是首元素地址，都是指针，所有我们接收的时候也要二级指针

4.2****二维数组传参

void test(int arr[3][5])//ok？ //ok

{} //形参传是二维数组，行是可以省略的，但是列不能省略。

void test(int arr[][])//ok？ //not ok - 不可传参

{}//列不可以省略

void test(int arr[][5])//ok？ //ok

{}
//总结：二维数组传参，函数形参的设计只能省略第一个[]的数字。
//因为对一个二维数组，可以不知道有多少行，但是必须知道一行多少元素。
//这样才方便运算。

void test(int *arr)//ok？ //error 整型指针

{}

void test(int* arr[5])//ok？ //error 数组

{}

void test(int (*arr)[5])//ok? //ok 指针数组

{}

void test(int **arr)//ok？//error

{}

int main()

{

int arr[3][5] = {0};

test(arr);//指的是第一行数组传参

}

4.3****一级指针传参

#include <stdio.h>
void print(int *p, int sz)
{
    int i = 0;
    for(i=0; i<sz; i++)
    {
        printf("%d\n", *(p+i));
    }
}
int main()
{
    int arr[10] = {1,2,3,4,5,6,7,8,9};
    int *p = arr;
    int sz = sizeof(arr)/sizeof(arr[0]);
    //一级指针p，传给函数
    print(p, sz);
    return 0;
}

思考：

当一个函数的参数部分为一级指针的时候，函数能接收什么参数？

比如：

void test1 ( int * p )
{}
//test1 函数能接收什么参数？
//test2函数能接收一个指向整形的指针作为参数;
//eg:具体数据类型的指针，指向结构体的指针，指向数组的指针，函数指针。
void test2 ( char* p )
{}
//test2 函数能接收什么参数？
//test2函数能接收一个指向字符的指针作为参数;
//eg:字符串字面量，字符数组，单个字符。

4.4****二级指针传参

#include <stdio.h>
void test(int** ptr)
{
    printf("num = %d\n", **ptr); 
}
int main()
{
    int n = 10;
    int*p = &n;
    int **pp = &p;
    test(pp);
    test(&p);
    return 0;
}

思考：

当函数的参数为二级指针的时候，可以接收什么参数？
eg:
1.指向指针的指针；
2.指向数组的指针的指针；
3.指向结构体的指针的指针；
4.函数指针的指针；

void test(char **p)
{ }
int main()
{
    char c = 'b';
    char*pc = &c;
    char**ppc = &pc;
    char* arr[10];
    test(&pc);
    test(ppc);
    test(arr);//Ok?
    return 0;
}

**5.**函数指针

//函数指针
//函数其实也是有地址的，函数名(或者&函数名)就是函数的地址；
首先看一段代码：

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

结果：

输出的是两个地址，这两个地址是 test 函数的地址。
那我们的函数的地址要想保存起来，怎么保存？
下面我们看代码：

void test()
{
    printf("hehe\n");
}
//下面pfun1和pfun2哪个有能力存放test函数的地址？
void (*pfun1)();
void *pfun2();

首先，能给存储地址，就要求 pfun1 或者 pfun2 是指针，那哪个是指针？
答案是：
pfun1 可以存放。 pfun1 先和 * 结合，说明 pfun1 是指针，指针指向的是一个函数，指向的函数无参数，返回值类型为void 。
分析下两段有趣的代码：

#include<stdio.h>
int main()
{
	//代码1
	(*(void (*)())0)();
	//代码2
	void (*signal(int, void(*)(int)))(int);
	return 0;
}

// 代码 1
( * ( void ( * )()) 0 )();
//( void ( * )()) - 函数指针类型
//把0强制转换为一种函数指针类型，无参无返回类型；
这段代码的意思是是将0强制类型转化为void (*)()类型的函数指针，然后再去调用0地址处的这个函数；
// 代码 2
void ( * ++signal(int , void(*)(int++ ++))++)( int );
//signal 是一个函数声明，声明的函数名字是signal，
signal 的参数有2个，第一个是int类型，第二个是函数指针:void(*)(int)，
该指针指向的函数参数int， 返回类型是void。
//signal 函数的返回类型也是函数指针，该指针指向的函数参数int , 返回类型是void .
//void (*p)(int) ; //p 是函数指针变量的名字

//typedef void(*pf_t)(int) ; //pf_t 是类型名

void (*signal(int, void(*)(int) ) )(int);
该代码是一次函数的声明，声明的函数名字叫signal
signal函数的参数有2个，第一个是int类型，第二个是函数指针类型
该函数指针能够指向的那个函数的参数是int，返回类型是void

signal函数的返回类型是一个函数指针
该函数指针能够指向的那个函数的参数是int, 返回类型是void
相当于三个套娃函数指针

简化一下（typedef）类型简化，typedef unsigned int uint;（简化方法）

typedef void(*pf_t)(int); //pfun_t就是函数指针的类型
pf_t signal(int, pf_t);//这就是简化完，

**6.**函数指针数组

数组是一个存放相同类型数据的存储空间，那我们已经学习了指针数组，
比如：

int * arr [ 10 ];
// 数组的每个元素是 int*
那要把函数的地址存到一个数组中，那这个数组就叫 函数指针数组 ，那函数指针的数组如何定义呢？
int ( * parr1 [ 10 ])();
int * parr2 [ 10 ]();
int ( * )() parr3 [ 10 ];
答案是： parr1
parr1 先和 [] 结合，说明 parr1 是数组，数组的内容是什么呢？
是 int (*)() 类型的函数指针。
函数指针数组的用途： 转移表
1.（计算器）
用我们以前的知识写出加减乘除计算器;

#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()
{
 int x, y;
 int input = 1;
    int ret = 0;
    do
   {
        printf( "*************************\n" );
        printf( " 1:add           2:sub \n" );
        printf( " 3:mul           4:div \n" );
        printf( "*************************\n" );
        printf( "请选择：" );
        scanf( "%d", &input);
        switch (input)
       { 
        case 1:
              printf( "输入操作数：" );
              scanf( "%d %d", &x, &y);
              ret = add(x, y);
              printf( "ret = %d\n", ret);
              break;
        case 2:
              printf( "输入操作数：" );
              scanf( "%d %d", &x, &y);
              ret = sub(x, y);
              printf( "ret = %d\n", ret);
              break;
        case 3:
              printf( "输入操作数：" );
              scanf( "%d %d", &x, &y);
              ret = mul(x, y);
              printf( "ret = %d\n", ret);
              break;
        case 4:
              printf( "输入操作数：" );
              scanf( "%d %d", &x, &y);
              ret = div(x, y);
              printf( "ret = %d\n", ret);
              break;
        case 0:
                printf("退出程序\n");
                breark;
        default:
              printf( "选择错误\n" );
              break;
       }
 } while (input);
    
    return 0;
}

使用函数指针数组的实现

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

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

//函数指针数组存放上述函数的地址
//但是也限定死了，只能是两个整型的操作数才能
//需要注意的是，我设置的计算是1，2，3，4，进入计算，所以第一个函数指针设置为0，后面对应1，2，3，4
int main()
{
	int input = 0;
	int x = 0;
	int y = 0;
    int (*p[5])(int, int) = { NULL, Add, Sub, Mul, Div };
	int ret = 0;
	do
	{
		menu();
		printf("请选择:>");
		scanf("%d", &input);
		//也需要判断我们输入的数进行选择
		if (input == 0)
		{
			printf("退出计算器\n");
			break;
		}
		else if (input >= 1 && input <= 4)
		{
			//直接用函数指针数组，用函数指针，直接进入到函数里，用不用*都一样
			printf("请输入两个操作数:>");
			scanf("%d %d", &x, &y);
			ret = pf[input](x, y);
			printf("ret = %d\n", ret);
		}
		else
		{
			printf("选择错误\n");
		}
	} while (input);

	return 0;
}

**7.**指向函数指针数组的指针

指向函数指针数组的指针是一个 指针,
指针指向一个 数组 ，数组的元素都是 函数指针 ;
如何定义？
函数指针数组------存放函数指针的数组（存放函数的地址）

int my_strlen(const char* str)
{
	return 0;
}
 
int main()
{
	//指针数组
	char* ch[5];
	int arr[10] = {0};

	//pa是数组指针
	int (*pa)[10] = &arr;
	
	//pf是函数指针
	int (*pf)(const char*) = &my_strlen;
 
	//函数指针数组
	int (*pfA[5])(const char*) = { &my_strlen };
	return 0;
}

定义：int (*parr1[10])(); parr1 先和 [] 结合，说明 parr1是数组，数组的内容是什么呢？

是 int (*)() 类型的函数指针。
//首先，函数指针数组是数组

parr[];

//数组的每个元素是函数指针,以无参函数，且无返回值的函数为例

void (*) ();

//结合后

void (*) () parr[];

//规范的写法

void (*parr[])()

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

**8.**回调函数

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

void menu()
{
	printf("*******************************\n");
	printf("****** 1. add   2. sub    *****\n");
	printf("****** 3. mul   4. div    *****\n");
	printf("****** 0. exit            *****\n");
	printf("*******************************\n");
}
 
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;
}
//回调函数，写一个函数指针指向函数，传进来都是计算用的函数指针
//把我计算用的这些Add，Sub等等这些函数，传给calc这个函数，然后用clac函数参数的部分是函数指针
//这个clac函数通用了，可以加减乘除，就看传谁的地址，通过传来的函数地址，去找到这个函数
void calc(int (*pf)(int, int))
{
	int x = 0;
	int y = 0;
	int ret = 0;
	printf("请输入两个操作数:>");
	scanf("%d %d", &x, &y);
	ret = pf(x, y);
	printf("%d\n", ret);
}
 
int main()
{
	int input = 0;
	
	do 
	{
		menu();
		printf("请选择:>");
		scanf("%d", &input);
		switch (input)
		{
		case 1:
			calc(Add);
			//把Add这个函数地址传给clac里面，就是pf这个函数指针，这个pf函数指针指向Add函数
			break;
		case 2:
			calc(Sub);
			break;
		case 3:
			calc(Mul);
			break;
		case 4:
			calc(Div);
			break;
		case 0:
			printf("退出计算器\n");
			break;
		default:
			printf("选择错误\n");
			break;
		}
	} while (input);
 
	return 0;
}

思路：先写一个calc函数，参数用函数指针来接受，前面写的有功能函数，在主函数中，调用calc函数，把功能函数的地址传到calc函数中，calc函数正好用函数指针来接受，calc函数中指针pf通过传来的功能函数地址，找到这些函数，去进行计算，然后返回值再打印，相当于calc就是一个实现计算过程的模型。

8.1.冒泡排序

两两相邻函数进行比较：(从小到大排序)

缺点：只能排序整数

void bubble_sort(int arr[], int sz)
{
	//趟数
	int i = 0;
	for (i = 0; i < sz - 1; i++)
	{
		//一趟冒泡排序的过程
		int j = 0;
		for (j = 0; j < sz-1-i; j++)
		{
			if (arr[j] > arr[j + 1])
			{
				int tmp = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = tmp;
			}
		}
	}
}
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);
	int i = 0;
	for (i = 0; i < sz; i++)
	{
		printf("%d ", arr[i]);
	}
}

8.2.qsort函数

void qsort(void* base, //待排序的数组的起始地址
	size_t num,    //元素个数
	size_t width,  //一个元素的大小
	int (*cmp)(const void* e1, const void* e2)//两个元素的比较函数
);

首先演示一下qsort函数的使用：

#include <stdio.h>
//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;
    int sz = sizeof(arr) / sizeof(arr[0]);
    
    qsort(arr, sz , sizeof (int), int_cmp);
    for (i = 0; i< sizeof(arr) / sizeof(arr[0]); i++)
   {
       printf( "%d ", arr[i]);
   }
    printf("\n");
    return 0;
}

qsort就是这样实现的，把你提供的函数 cmp_int 地址传到qsort，qsort里用函数指针去接收，然后去指向这个函数，也就是一个回调函数，e1，e2，是要比较的这两个元素的地址，e1<e2返回小于零的数

8.3.用qsort来改正冒泡排序

冒泡排序可以排任何类型的，进行改造，怎么改

第一层循环是不变的，内部两两比较也不变，变的是判断，整型大小比较才能用大小号，字符或者浮点型比较方法不一样，当我们想让这个冒泡排序任何地方使用，是不是就是把比较的部分抽出来，你想排序整型，你自己提供一个排序整型的方法，想排序啥样的，就提供什么样子的

函数1是用库函数qsort排序整型

函数2是用库函数qsort排序结构体

函数3是用冒泡排序模拟实现库函数qsort排序整型

函数4是用冒泡排序模拟实现库函数qsort排序结构体

int cmp_int(const void* e1, const void* e2)
{
	return *(int*)e1 - *(int*)e2;
	//参数是无类型的指针来接受，所以这里要强制类型转化为int，然后再解引用
}
//对于整型的排序
void test1()
{
 
	int arr[] = { 9,8,7,6,5,4,3,2,1,0 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	qsort(arr, sz, sizeof(arr[0]), cmp_int);
	int i = 0;
	for (i = 0; i < sz; i++)
	{
		printf("%d ", arr[i]);
	}
}
//先定义一个结构体
struct Stu
{
	char name[20];
	int age;
};
 
//先对结构体的年龄比较
int cmp_stu_by_age(const void* e1, const void* e2)
{
	return ((struct Stu*)e1)->age - ((struct Stu*)e2)->age;
	//参数是无类型的指针来接受，所以这里要强制类型转化为struct Stu*，相当于拿到了结构体指针，然后再箭头指向年龄
}
//再对结构体的名字比较
int cmp_stu_by_name(const void* e1, const void* e2)
{
	return strcmp(((struct Stu*)e1)->name, ((struct Stu*)e2)->name);
	//参数是无类型的指针来接受，所以这里要强制类型转化为struct Stu*，相当于拿到了结构体指针，然后再箭头指向名字
	//名字比是字符串比较不能用减号了，用函数strcmp，比较对应位置上的字符，strcmp返回值跟qsort返回值一样的
}
//对于结构体的排序
void test2()
{
	//结构体的描述
	struct Stu s[3] = { {"zhangsan",20}, {"lisi", 50}, {"wangwu", 33} };
	int sz = sizeof(s) / sizeof(s[0]);
	qsort(s, sz, sizeof(s[0]), cmp_stu_by_age);
	qsort(s, sz, sizeof(s[0]), cmp_stu_by_name);
}
 
上面test1和test2是用库函数qsort来排序整型和结构体
上面test3和test4是用冒泡排序的思想模拟实现qsort来排序整型和结构体
 
//改造冒泡排序函数，使得这个函数可以排序任意指定的数组
void bubble_sort(void* base, size_t sz, size_t width, int (*cmp)(const void* e1, const void* e2))
//为了能接收各种类型所以void* base，sz就是元素的个数， width宽度你只知道个数，宽度为了知道几个字节，最后用函数指针用来，在这个函数中指针接收要比较的地址
{
	size_t i = 0;
	for (i = 0; i < sz - 1; i++)
	{
		size_t j = 0;
		for (j = 0; j < sz - 1 - i; j++)
		{
			if (cmp((char*)base + j * width, (char*)base + (j + 1) * width) > 0)
			//这里是找我们要比较的那俩地址，最开始是base，我们用width去找这一对，往后跳对应字节去找，用j可以找后面所有的要比较的数了
			//然后这俩地址传给e1，e2，就是通过指针找到比较函数
			{
				Swap((char*)base + j * width, (char*)base + (j + 1) * width, width);
				 //交换，交换函数，先把这俩地址给我，再把宽度给我
			}
		}
	}
}
//交换函数，用char接收，然后也接收宽度，交换的细节，是一个字节的交换，不是整个的交换，然后往后跳
void Swap(char* buf1, char* buf2, int width)
{
	int i = 0;
	for (i = 0; i < width; i++)
	{
		char tmp = *buf1;
		*buf1 = *buf2;
		*buf2 = tmp;
		buf1++;
		buf2++;
	}
}
 
//使用我们自己写的bubble_sort函数排序整型数组
void test3()
{
	int arr[] = { 9,8,7,6,5,4,3,2,1,0 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	bubble_sort(arr, sz, sizeof(arr[0]), cmp_int);
	//我们arr传给base，最开始的地址是base，第二个是加上一个，但是是无类型的，要给她类型
	//但是给他什么类型，也不能写死，所以我们用我们写的宽度，单位是字节，所以我们转化为char的指针
	//然后我找base后面的地址，就可以用字节（宽度）跳过
	int i = 0;
	for (i = 0; i < sz; i++)
	{
		printf("%d ", arr[i]);
	}
}
 
//使用我们自己写的bubble_sort函数排序结构体数组
//结构体的时候跟上面的是一样的
void test4()
{
	struct Stu s[3] = { {"zhangsan",20}, {"lisi", 50}, {"wangwu", 33} };
	int sz = sizeof(s) / sizeof(s[0]);
	bubble_sort(s, sz, sizeof(s[0]), cmp_stu_by_age);
	bubble_sort(s, sz, sizeof(s[0]), cmp_stu_by_name);
}
 
int main()
{
	//用库函数qsort实现排序
	test1();//整型
	test2();//结构体
	//自己用冒泡排序的思想模拟实现qsort
	test3();//整型
	test4();//结构体
	return 0;
}

函数1，函数2，就是我们上面用库函数来进行排序，很方便，只要我们创建一个类型函数，是要去排序整型还是结构体还是其他的，我们去创建一个，然后用函数指针去接收；

函数3，函数4，就是我们用冒牌排序的思想模拟实现这个库函数，在分析一下。
bubble_sort(arr, sz, sizeof(arr[0]), cmp_int);

传要排序的数组，个数，字节，还有我们提供的函数地址

bubble_sort(s, sz, sizeof(s[0]), cmp_stu_by_age);

bubble_sort(s, sz, sizeof(s[0]), cmp_stu_by_name);

结构体也是一样的，要传过去什么，最重要的是我们提供的函数

首先就是用什么去接收

void bubble_sort(void* base, size_t sz, size_t width, int (*cmp)(const void* e1, const void* e2))

为了能接收各种类型所以void* base，sz就是元素的个数， width宽度你只知道个数，宽度为了知道几个字节，最后用函数指针用来，在这个函数中指针接收要比较的地址

然后就是去判断两个比较数

if (cmp((char*)base + j * width, (char*)base + (j + 1) * width) > 0)

这里是找我们要比较的那俩地址，最开始是base，我们用width去找这一对，往后跳对应字节去找，用j可以找后面所有的要比较的数了，然后这俩地址传给e1，e2，就是通过指针找到比较函数

判断完去交换位置

Swap((char*)base + j * width, (char*)base + (j + 1) * width, width);

交换，交换函数，先把这俩地址给我，再把宽度给我

思路：

当我们整体看的时候，我们先进入到test3函数中，到我们的冒泡排序bubble_sort中传入数据

传到cmp_int时候，是把cmp_int函数的地址传到bubble_sort函数中的参数int(*cmp)(const void* e1, const void* e2)函数指针中，也就是cmp

所以我bubble_sort函数中的cmp指针指向的就是cmp_int函数，然后我们开始进入循环然后到判断，利用base和wide宽度找到要比较的两个数的地址

由cmp指针指向到cmp_int函数（把这俩比较数的地址传来，给e1，e2）然后算出返回值，然后看是否进行交换，进入到swap交换函数中去交换。
9. 指针和数组笔试题解析

// 一维数组
int a [] = { 1 , 2 , 3 , 4 };
printf ( "%d\n" , sizeof ( a ));
//数组名a单独放在sizeof内部，计算的是整个数组的大小，单位是字节，4*4=16；
printf ( "%d\n" , sizeof ( a + 0 ));
//a表示数组首元素地址，a+0还是数组首元素的地址，是地址大小4/8(字节);
printf ( "%d\n" , sizeof ( * a ));
//a表示的首元素的地址，*a就是对首元素的地址的解引用，就是首元素，大小为4字节；
printf ( "%d\n" , sizeof ( a + 1 ));
//a表示首元素的地址，a+1是第二个元素的地址，是地址，大小就是4/8个字节；
printf ( "%d\n" , sizeof ( a [ 1 ]));
//a[1]是第二个元素，大小是4个字节；
printf ( "%d\n" , sizeof ( & a ));
//&a表示的是数组的地址，但也是地址，地址大小就是4/8个字节；
printf ( "%d\n" , sizeof ( *& a ));
//可以理解为* 和 & 抵消效果，(*&a)相当于a, sizeof(a) 是16 个byte；
printf ( "%d\n" , sizeof ( & a + 1 ));
//&a 是数组的地址，&a+1 跳过整个数组后的地址，是地址就是4/8；
printf ( "%d\n" , sizeof ( & a [ 0 ]));
//&a[0] 取出数组第一个元素的地址，是地址就是4/8；
printf ( "%d\n" , sizeof ( & a [ 0 ] + 1 ));
//&a[0]+1 就是第二个元素的地址，是地址大小就是4/8(字节)；
// 字符数组
char arr [] = { 'a' , 'b' , 'c' , 'd' , 'e' , 'f' };
printf ( "%d\n" , sizeof ( arr ));
//arr 作为数组名单独放在sizeof 内部，计算的是整个数组的大小，单位字节，6；
printf ( "%d\n" , sizeof ( arr + 0 ));
//arr 就是首元素的地址，arr+0 还是首元素的地址，地址大小就是4/8；
printf ( "%d\n" , sizeof ( * arr ));
//arr 就是首元素的地址，*arr 就是首元素，是一个字符，大小是1个字节；
printf ( "%d\n" , sizeof ( arr [ 1 ]));
//arr[1] 是数组的第二个元素，是一个字符，大小是1个字节；
printf ( "%d\n" , sizeof ( & arr ));
//&arr 取出的是数组的地址，数组的地址也是地址，地址就是4/8个字节；
printf ( "%d\n" , sizeof ( & arr + 1 ));
//&arr 取出的是数组的地址，&arr+1 代表了跳过了整个数组，&arr+1还是地址，地址的大小为4/8 byte；
printf ( "%d\n" , sizeof ( & arr [ 0 ] + 1 ));
//&arr[0] 是第一个元素的地址，&arr[0]+1 就是第二个元素的地址，地址就是4/8个字节；
printf ( "%d\n" , strlen ( arr ));
//arr 是首元素的地址，但是arr数组中没有'\0', 计算的时候不知道停止，是随机值；
printf ( "%d\n" , strlen ( arr + 0 ));
//arr 是首元素的地址，arr+0 还是首元素的地址，结果是：随机值；
printf ( "%d\n" , strlen ( * arr ));
//err, strlen 需要的是一个地址，从这个地址开始向后找字符，直到'\0'，统计字符个数，但是*arr是数组的首元素，也就是'a', 这是传给strlen的ascll码值97，strlen函数会把97作为起始地址，统计字符串，会形成内存访问冲突；
printf ( "%d\n" , strlen ( arr [ 1 ]));
//err,同上，和上一个一样，内存访问冲突；
printf ( "%d\n" , strlen ( & arr ));
//&arr是arr数组的地址，虽然类型和strlen的参数类型有所差异，但传参过去后，还是从第一个字符的位置向后数字符，结果随机值；
printf ( "%d\n" , strlen ( & arr + 1 ));
//随机值；
printf ( "%d\n" , strlen ( & arr [ 0 ] + 1 ));
//&arr[0] 代表第一个元素，&arr[0]+1 代表第二个元素，向后计算，结果随即值；
char arr [] = "abcdef" ; //计算结果
printf ( "%d\n" , sizeof ( arr )); //7；
//sizeof是C和C++中的操作符，用于返回其操作数的大小(以字节为单位)，他返回的是字符串数组的大小，包括字符串末尾的'\0', 所以它的值为7；
printf ( "%d\n" , sizeof ( arr + 0 )); //arr+0 代表首元素的地址，4/8byte；
printf ( "%d\n" , sizeof ( * arr )); //*arr 代表首元素，大小1 byte;
printf ( "%d\n" , sizeof ( arr [ 1 ])); //1 byte; *(arr+0) =>arr[0];
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 )); //结果为：6byte;
printf ( "%d\n" , strlen ( arr + 0 )); //结果为：6byte;
printf ( "%d\n" , strlen ( * arr )); //err
printf ( "%d\n" , strlen ( arr [ 1 ])); //err
printf ( "%d\n" , strlen ( & arr )); //6 byte;
printf ( "%d\n" , strlen ( & arr + 1 )); //随机值；
printf ( "%d\n" , strlen ( & arr [ 0 ] + 1 )); //5 byte;
char * p = "abcdef" ;
printf ( "%d\n" , sizeof ( p ));
//p是一个指针变量，sizeof(p)计算的就是指针变量的大小，4/8个字节；
printf ( "%d\n" , sizeof ( p + 1 ));
//p是指针变量，是存放地址的，p+1 也是地址，地址大小是4/8个字节；
printf ( "%d\n" , sizeof ( * p ));
//p是char* 指针，解引用访问1个字节，sizeof(*p)是1个字节；
printf ( "%d\n" , sizeof ( p [ 0 ]));
//p[0]=>*(p+0) => *p, 同上，1个字节；
printf ( "%d\n" , sizeof ( & p ));
//&p 也是地址，是地址就是4/8字节，&p 是二级指针；
printf ( "%d\n" , sizeof ( & p + 1 ));
//&p 是地址，&p+1 还是地址，是地址就是4/8个字节；
printf ( "%d\n" , sizeof ( & p [ 0 ] + 1 ));
//p[0]就是a, &p[0] 就是a的地址，&p[0]+1 就是b的地址，是地址就是4/8 byte;
printf ( "%d\n" , strlen ( p ));
//p中存放的是'a'的地址，strlen(p)就是从'a'的位置向后求字符串的长度，长度是6；
printf ( "%d\n" , strlen ( p + 1 ));
//p+1 是'b'的地址，从'b'的位置开始求字符串长度是5；
printf ( "%d\n" , strlen ( * p ));
//err ;
printf ( "%d\n" , strlen ( p [ 0 ]));
//err ; p[0] => *(p+0) -> *(p)
printf ( "%d\n" , strlen ( & p ));
//随机值；
printf ( "%d\n" , strlen ( & p + 1 ));
//随机值；
printf ( "%d\n" , strlen ( & p [ 0 ] + 1 ));
//p[0]->*(p+0)->*p -> 'a', &p[0] 就是首字符的地址，&p[0]+1 就是第二个字符的地址，从第二个字符的位置向后数字符串，长度是5；
// 二维数组
int a [ 3 ][ 4 ] = { 0 }; //计算结果
printf ( "%d\n" , sizeof ( a )); //48 = 3(行)*4(列)*4(int)
printf ( "%d\n" , sizeof ( a [ 0 ][ 0 ])); //4：第一行第一个元素；
printf ( "%d\n" , sizeof ( a [ 0 ])); //16 = 3(个)*4(int)，第一行大小；
printf ( "%d\n" , sizeof ( a [ 0 ] + 1 )); //4 ：第一行第二个元素；
printf ( "%d\n" , sizeof ( * ( a [ 0 ] + 1 ))); //4 ：第一行第二个元素；
printf ( "%d\n" , sizeof ( a + 1 )); //4/8 ： 第二行地址；
printf ( "%d\n" , sizeof ( * ( a + 1 ))); //16；
printf ( "%d\n" , sizeof ( & a [ 0 ] + 1 )); //4/8：第二行地址；
printf ( "%d\n" , sizeof ( * ( & a [ 0 ] + 1 ))); //16；
printf ( "%d\n" , sizeof ( * a )); //16；
printf ( "%d\n" , sizeof ( a [ 3 ])); //16；
总结：
数组名的意义：

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

结束语

在看完以上内容后，对指针就有了一些了解，本文如有错误的地方，肯请多多指正。。。

希望大家共同进步。