计算机的硬件——CPU——支持32位虚拟地址空间和 64位虚拟地址空间

32位虚拟地址空间—CPU产生32bit位虚拟地址

64位虚拟地址空间—CPU产生64bit位虚拟地址

虚拟地址——编译器中打印的地址——在实际访问空间时需要转换成物理地址才能访问到内存空间

物理地址——访问内存空间的地址

cpu通过地址线进行传递，产生虚拟地址，虚拟地址通过硬件和软件的转换，变成物理地址，访问内存空间

字符指针：

一般使用：int? main()

?? ??? ??? ?? ? {

?? ??? ??? ??? ?? ? char? ch='w';

?? ??? ??? ??? ?? ? char*? pc=&ch;

?? ??? ??? ??? ?? ? return? 0;

?? ??? ??? ??? ?}

其他使用：

int? ? main()

{

? ? char*? p="abcdef";? //"abcdef"是一个常量字符串，常量字符串不可更改? ??//p中存入的是a的地址

? ? printf("%c ",*p);? ?? ? //打印出a

}

//"abcdef"储存在内存中的只读数据区

错误示例：

int? main()

{

? ? char* p="abcdef";

? ? *p='w';?? ?? ??? ?//发生段错误

? ? printf("%s",p);//在vs2013一般状态下，不会报错，但实际是会系统崩溃的

}

int? ? main()

{

? ? char? arr1[]="abcdef";?? ??? ??? ?? ? 由char加数组定义的字符串为变量

? ? char? arr2[]="abcdef";?? ??? ??? ?? ? 由char*+指针变量名指向的字符串（直接打出来，不是数组中的字符串）为常量字符串

? ? char* p="abcdef";

? ? char* q="abcdef";

? ? if(arr1==arr2)? ? ? ? ? ? ? //数组名数值上表现为地址

?? ?? ? printf("hehe");

? ? else?? ??? ??? ??? ??? ??? ??? ?? //打印haha

?? ?? ? printf("haha");?

?? ?if(p==q)? ? ? ? ? ? ? ? ? ? ? //"abcdef"为常量字符串,指针所指向的为同一空间

? ? ? ? printf("hehe");? ? ? ? ? //指针指向的，为独立于数组arr1，arr2空间的另一块空间?

? ? else?? ??? ??? ??? ??? ??? ??? ? ?//打印hehe

? ? ? ? printf("haha");???? ?? //"abcdef"为常量字符串//常量字符串不可更改，只需要储存一份，所以两个指针指向的是同一空间

}

int a,b; //a,b都是int类型

int* a,b; //a是int*类型，b是int类型

int* a,*b; //这样定义才能使ab都为指针类型

若typedef? int*? pint //typedef是类型重命名，pint是一个新的类型

pint? pa,pb; //pa，pb类型都为int*

若#define? pint? int*? / /#define是替换，相当于把int*替换换 成pint

pint? pa,pb; //int*? pa,pb; //pa是int*类型，pb是int类型

指针数组

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

示例：int*? parr[5];//存放5个整形指针的数组——指针数组——每个元素类型是int*

?? ??? ?? char*? carr[10];//存放10个字符指针的数组——指针数组——每个元素类型是char*

?? ?? ? ? char ** arr[5];//存放5个二级字符指针的数组——指针数组——每个元素类型是char* *

?? ??? ?（初始化大括号赋0即可（{0}），数字0在指针中可以被认为是NULL）

使用示例：

例1

int main()

{

????????int i;

????????int a[5] = { 1,2,3,4,5 };

????????int b[5] = { 3,4,5,6,7 };

????????int c[5] = { 4,6,8,9,10 };

????????int* p[3] = { a,b,c };

????????for (i = 0; i <= 2; i++)

????????{

???????????????int j = 0;

???????????????for (j = 0; j < 5; j++)

???????????????{

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

???????????????}

???????????????printf("\n")；

????????}

????????return 0;

}

例2

int? main()

{

? ? const? char*? arr[]? =? { "abcdef","qwer","xyz" };

//将"abcdef","qwer","xyz"的首地址分别存储到数组arr的空间中

? ? int? i? =? 0;

? ? int? sz? =? sizeof(arr) / sizeof(arr[0]);

? ? for(i = 0; i < sz; i++)

? ? {

?? ?? ? printf("%s",arr[i]);

?? ?}?

?? return? 0;

}

例3

int? main()

{

? ? int arr1[] = {1,2,3,4,5};

? ? int arr2[] = {2,3,4,5,6};

? ? int arr3[] = {3,4,5,6,7};

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

//数组arr中存放arr1,arr2,arr3的首地址

? ? int? i? =? 0;

? ? int? sz? =? sizeof(arr) / sizeof(arr[0]);

? ? for(i = 0; i < sz; i++)

? ? {

?? ?? ? int? j? =? 0;

?? ?? ? for(j = 0; j < 5; j++)

?? ??? ?{

?? ??? ?? ? printf("%d ",arr[i][j]); //模拟的二维数组

?? ?? ? }

?? ?? ? printf("\n");

?? ?}?

?? return? 0;

}

打印结果：

1 2 3 4 5

2 3 4 5 6

3 4 5 6 7

数组指针——疑难

数组指针是一种指针，指针指向数组，存放数组的地址

示例：

int? ? main()

{

? ? int? ? arr[10]={1,2,3,4,5,6,7,8,9,10};

? ? int (*p)[10]=&arr;?? ??? ??? ??? ??? ??? ?? //不加括号，[]的优先级比*高，p[]是一个数组，加上括号*p是指针

//&是取地址，p解引用后是拿到arr

? ? return 0;

}

int? ? main()

{

? ? char* arr[5];

? ? char* (*p)[5]=&arr;?? ?? ? //*p说明是一个指针，5是指指向的数组有5个元素，char*指针指向的元素类型

? ? return 0;?

}

数组名是数组首地址，&数组名是数组地址

数组名+1和&数组名+1的效果不一样，数组名的类型是char*，&数组名的类型是char*(*)[5]

数组名和&数组名的值是一样的

数组指针使用示例：

int? ? main()

{

? ? int a[10]={1,2,3,4,5,6,7,8,9,10};

? ? int (*p)[10]=&a;

? ? int i;

? ? for(i=0;i<10;i++)

? ? {

?? ?? ? printf("%d",(*p)[i]);? ? //*((*p)+i)//解引用p相当于拿到数组名

?? ??? ?//这样使用效率低，所以一般用于二维数组

?? ?}

}

数组指针实际应用于二维以上的数组

void print1(int a[3][5], int x, int y) //参数是数组形式，二维数组传参，二维数组接收

{

????????int i;

????????for (i = 0; i <x; i++)

????????{

???????????????int j = 0;

???????????????for (j = 0; j < y; j++)

???????????????{

???????????????????????printf("%d\t", a[i][j]);

???????????????}

???????????????printf("\n");

????????}

}

void print2(int (*p)[5],int x,int y) //参数是指针形式，二维数组首元素相当于a[0]一维数组

{

????????int i;

????????for (i = 0; i < x; i++)

????????{

???????????????int j = 0;

???????????????for (j = 0; j < y; j++)

???????????????{

???????????????????????printf("%d\t", *(*(p+i)+j));//*(p[i]+j) //(*(p+i))[j]

?? ??? ??? ??? ??? ?? ? //*(p+i)相当于拿到第i行第1个元素的首地址

???????????????}

???????????????printf("\n");

????????}

}

int main()

{

????????int a[3][5] = { { 1,2,3,4,5 } ,{ 3,4,5,6,7 } ,{ 4,6,8,9,10 } };

????????print1(a, 3, 5);

????????print2(a, 3, 5); //将二维数组化为一维数组，首元素为{1,2,3,4,5}

????????return 0;

}

int?arr[5]

//arr是一个有五个元素的整形数组

int *parr1[10]?

//parr1是一个数组，数组有10个元素，每个元素的类型是int*，parr1是一个指针数组

int (*parr2)[10]?

//parr2是一个指针，该指针指向一个数组，数组有十个元素，每个元素类型是int，parr2是数组指针

int (*parr3[10])[5]

//parr3是一个数组，该数组有10个元素，每个元素是一个数组指针，该指针指向的数组有5个元素， 每个元素类型是int， parr3[10]明确了数组名和元素个数，剩下的是元素类型int(*? ?)[5]，为数组指针.

//对数组指针解引用相当于拿到数组名

//去掉变量名，剩下的就是类型

//示例int (*parr2)[10]去掉变量名parr3剩下的int (*)[10]为类型

数组传参，指针参数

写代码时，需要把数组和指针传给函数

void? test(int* arr[]) //或void? test(int** arr);//数组传给同类型数组，数组首元素是指针，指针的地址用二级指针储存

……

int*?arr[20]={0}; //arr是数组，传参传数组首地址。

test(arr);

……

当形参是指针时，实参可以是指针，也可以是类型变量的地址

一维数组传参：

#include<stdio.h>

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

{}

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

{}

void? test( int* arr ) //ok

{}

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

{}

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

{}

int? main()

{

? ? int? arr[10] = {0};

? ? int*? arr2[20] = {0};

? ? test(arr);

? ? test2(arr2); //arr2是指针数组，每个元素类型是int*，一级指针数组的首地址是一个二级指针

?? ?//一级指针做作实参时，形参不能为二级指针，形参若为二级指针，实参要&一级指针

? ? return? 0;

}

二维数组的传参，行可以省略，列不可省略，同样传数组首地址(二维数组首元素为第一行，首元素的地址为第一行的地址)。

二维数组在内存中存储的方式同一维数组：开辟行标乘列标个数的连续类型（int char ……）空间

二维数组传参不能使用指针int* p接收，二维数组首元素的地址是第一行的地址，类型为数组指针，不能使用整形指针接收

一级指针可以存放在一级指针中，一级指针的地址存放在二级指针中。

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

{}

void? test( int arr[ ][ ] ) //no

{}

void? test( int arr[0][5] ) //ok

{}

//二维数组传参列不能省略，因为要确认arr+1要跳过多大的空间

// 列的作用，决定数组在进入下一行时，跳过的字节数为：列下标*类型字节。

// 示例int? [][4]跳到下一行跳过字节数为：4*sizeof（int）=16；char [][3]跳到下一行，跳过的字节数为3*sizeof（char）=3.

void? test2( int* arr ) //no

{}

void? test2( int* arr[5] ) //no

{}

void? test( int (*arr)[5] ) //ok

{}

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

{}

int? main()

{

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

? ? test(arr);

? ? return? 0;

}

//对数组指针解引用相当于拿到数组名

函数指针——指向函数的指针

int? add(int x , int y)

{

? ? return? x + y;

}

int? main()

{

?? ? printf("%p\n",? &add);

?? ? printf("%p\n",? add);

? ? ? //两者打印的值相等

? ? ?//不同于数组，&数组名与数组名不等价，函数没有首元素，&函数名与函数名是等价的

? ? ?return? 0;

}

如果想要将函数地址存起来，则需要函数指针，定义方式与其他指针不同

首先定义函数名：pf，类型为指针：*pf，指向的函数参数类型为int，int：*pf(int , int)，防止先与参数类型结合将指针框起来：(*pf)(int , int)，指针指向函数返回值为int：int (*pf)(int , int)。所以该指针指向一个参数类型为(int，int)，返回值为int的函数

该指针变量的变量名为pf，类型名为int (*)(int , int)。

指针调用：

int (*pf)(int , int) = &add; //int (*pf)(int , int) = add;

int sum = (*pf)(2,3); //对指针解引用找到对应函数，用函数调用操作符()对函数传参

使用函数时函数名+函数调用操作符即可，现在已知函数名就是函数地址，当把函数地址赋给指针后，直接使用指针进行调用，不进行解引用的效果会不会和函数一样？

答案是肯定的，int? sum = pf(2,3);的结果和int sum = (*pf)(2,3);一样

变态代码其一：(*( void ( * ) ( ))0) ( );

想要理解含义需要清楚每个括号的含义，由上文得知，函数指针的定义方式和其他指针不同，是由返回值类型+( * )+(?参数类型 )构成的。由此可知void ( * ) ( )是一个函数类型指针，剩下的(*(?类型 )0)( )就很方便理解了。将0强制类型转换为函数指针类型，再解引用，最左边的( )是函数调用操作符。因为强制类型转换时参数类型为空【(*( void ( * ) ( ))0) ( );】，所以使用函数调用操作符时参数类型也为空【(*( void ( * ) ( ))0) ( );】。这是一次函数调用，调用0地址处的函数。

这段程序只是解析是什么意思。在指针中0可以被视为NULL，用户程序是不能直接访问0地址处的

变态代码其二：void( *signal ( int, *void ( * ) ( int ) ) ) ( int );

同样void ( * ) ( int )为函数指针类型，剩下部分为【void( *signal ( int, *(指针类型) ) ) ( int );】。signal是和后面的()结合，所以signal不是指针。而signal调用没有变量名，所以signal是一个函数声明，函数名，参数类型都有了，还缺返回类型。将已知的去掉得到【void( *? ? ? ? ? ? ? ? ? ? ? ?) ( int );】。这就是返回类型了。返回类型是一个函数指针。所以signal是一个函数声明。(int)是否可以移动到左边？不可以，*要始终和函数名结合。至于为什么要和函数名结合，我也不知道，就当语法规则吧

将函数声明简化：typedef? void? (* ) ( int )? pfun_t;(错误)，typedef? void? (*pfun_t ) ( int );(正确)

化简后：pfun_t? signal ( int, pfun_t );

void (*p) ( int )? ? ?//p是指针变量名

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

对数组的重定义：typedef? int? T[10]，是对int [10]类型的重定义，T?a[20]等价于a[20][10]。

函数指针数组——储存函数指针的数组——也叫转移表

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;

}

int? main()

{

? ? int (*pf1)( int , int ) = add;

? ? int (*pf2)( int , int ) = sub;

? ? int (*pf3)( int , int ) = mul;

? ? int (*pf4)( int , int ) = div;

? ? return 0;

}

当参数类型相同，返回值类型相同时，可以定义函数指针数组存储4个函数地址

函数指针数组使用示例：

int (*pfarr[4])( int , int ) = {add , sub , mul , div}; //初始化

int?i = 0;

for(i = 0 ; i < 4 ; i++)

{

? ? int ret = pfarr[i](8,4);

? ? printf("%d\n",ret);

}

应用示例：

#include<stdio.h>

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[5])(int, int) = { 0,add,sub,mul,div };

??? do

??? {

??????? menu();

??????? scanf("%d", &input);

??????? if (input == 0)

??????? {

??????????? printf("退出计算器\n");

??????????? break;

??????? }

??????? else if (input >= 1 && input <= 4)

??????? {

??????????? printf("输入两个数\n");

??????????? scanf("%d%d", &x, &y);

??????????? ret = pfarr[input](x, y);

??????????? printf("%d\n", ret);

??????? }

??????? else

??????? {

??????????? printf("选择错误\n");

??????? }

??? } while (input);

??? return 0;

}

不使用函数指针数组的话就只能用switch一个一个判断，这样case:部分的代码会大量重复，而且使用函数指针数组后，添加其他功能只需要补充函数块，菜单，和函数指针数组里的内容就可以了

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

int? add(int? x, int? y)

{

? ? return? 0;

}

int? main()

{

? ? int (*p)( int , int ) = add; //函数指针

? ? int (*? pf[4])( int , int ); //函数指针数组

? ??int (*? (*ppf)[4])( int , int ) = &pf; //ppf是一个指针，该指针指向一个存放函数指针的数组?

? ? //指向函数指针数组的指针在书写时，从对应函数指针数组中复制框架，然后在使其变为指针

}

函数指针的应用

#include<stdio.h>

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;

}

void? calc(int (*pf)(int , int)) //通过函数指针来接收函数地址

{

?? ?int x = 0;

??? int y = 0;

??? int ret = 0;

? ? printf("输入两个操作数\n");

? ? scanf("%d%d", &x, &y);

? ? ret = pf(x,y);

? ? printf("ret = %d", sum);

}

int? main()

{

??? int input = 0;

????

??? do

??? {

??????? menu();

?? ?? ? printf("请选择>:");

?? ?? ? scanf("%d",&input);

? ? ? ? switch(input)

?? ?? ? {

?? ??? ??case 1:

?? ??? ??? ?? calc(add);

?? ??? ??? ?? break;?

?? ??? ??case 2:

?? ??? ??? ?? calc(sub);

?? ??? ??? ?? break;?

?? ??? ??case 3:

?? ??? ??? ?? calc(mul);

?? ??? ??? ?? break;?

?? ??? ??case 4:

?? ??? ??? ?? calc(div);

?? ??? ??? ?? break;??

?? ??? ?}

??? } while (input);

??? return 0;

}

//利用函数指针将差异化的代码转换为一个代码

回调函数——即如函数指针应用部分所示

回调函数是通过函数指针调用的函数。如果你将函数的地址作为参数传递给另一个函数，当这个地址被用来调用其所指向的函数时，我们说这是回调函数。即将add的地址传给calc后，通过calc中的pf调用add函数时，被调用的add函数称为回调函数。回调函数不是由实现方直接调用，而是由特定的事件或条件发生时由另外一方调用的，用于对事件或条件进行响应。即add等函数没有直接调用，而是传递给calc，根据input的不同而做出不同的响应。

void? bubble_sort(int *p,int sz)

{

? ? int i = 0;

? ? int j = 0;

?? ?for(i = 0; i < sz-1; i++)

? ? {

?? ?? ? for(j = 0; j < sz-i-1; j++)

?? ?? ? {

?? ??? ?? ? if(p[j] > p[j+1])

?? ??? ?? ? {

?? ??? ??? ??? ?int tmp = p[j+1];

?? ??? ?? ? ?? ?p[j+1] = p[j];

?? ??? ??? ?? ? p[j] = tmp;

?? ??? ?? ? }

?? ??? ?}

?? ?}

}

void print_bubble(int *p,int sz)

{

? ? int i = 0;

? ? for(i = 0; i < sz; i++)

? ? {

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

?? ?}

}

int? main()

{

? ? int sz = 0;

? ? int arr[10] = {2,5,8,3,6,9,0,1,4,7};

? ? sz = sizeof(arr)/sizeof(arr[0]);

? ? bubble_sort(arr,sz);

? ? print_bubble(arr,sz);

? ? return? 0;

}

如上工程所示，这是一个简单的冒泡排序，但仅仅可以排序整型数组，想办法使其可以排序任意类型

通过C语言提供的库函数qsort来参考，qsort——通过快速排序的方法实现——快速排序和冒泡排序一样是一种排序算法

void qsort(void*?base, //指针//要排序数据的起始位置

?? ??? ??? ??? ? ? size_t?num , //size_t是unsigned?int//数组元素个数

?? ??? ??? ??? ?? size_t width, //一个元素所占字节大小

?? ??? ??? ??? ? ? int (* compare)(const void* e1 , const void* e2) //函数指针//在使用时传一个比较函数

?? ??? ??? ??? ??? );

compare函数必须满足以下条件：

e1>e2——返回大于0的数

e1=e2——返回0

e1<e2——返回小于0的数

qsort可以排序包含字符型，整型，字符串型，结构体型等类型的数据

比较函数中void*是无具体类型的指针，该指针具有如下特性：

1.可以存储任意类型地址

2.不可以直接进行解引用操作，需要进行强制类型转换后进行解引用操作

3.不能直接进行加减操作，需要进行强制类型转换后进行加减

int cmp_int (const void* e1 , const void* e2) //比较e1，e2指向的数据

{

? ? if( *(int*)e1 >? *(int*)e2 ?)

?? ?? ? return? 1;

? ? else?? if( *(int*)e1 <? *(int*)e2 ?)

?? ? ? ? return? -1;

? ? else

? ? ?? ?return? 0;

} //cmp_int满足compare函数的条件

//化简cmp_int:? return?? *(int*)e1 -?*(int*)e2

int? main()

{

? ? int sz = 0;

? ? int arr[10] = {2,5,8,3,6,9,0,1,4,7};

? ? sz = sizeof(arr)/sizeof(arr[0]);

? ? qsort(arr , sz , sizeof(arr[0]) , cmp_int); //默认排序方式为升序，若想排降序，e1e2位置需要互换

? ? //qsort可以完成数组内容所有元素的比较，并进行排序

? ? return? 0;

}

对结构体排序：

struct? stu

{

? ? char? name[20];

? ? int? age ;

? ? float? sorce;

};

int? cmp_struct_by_name(const? void* e1 , const? void* e2)

{

? ? return? ?strcmp(((struct? stu*)e1)->name , ((struct? stu*)e2)->name);

? ? //strcmp的比较方式是比较首字符的ascall码值，相同就比较下一个字符，全部相同才返回0

}

int? cmp_struct_by_age(const? void* e1 , const? void* e2)

{

? ? return? ((struct? stu*)e1)->age - ((struct? stu*)e2)->age;

}

int? cmp_struct_by_sorce(const? void* e1 , const? void* e2)

//只需要满足比较函数条件即可，实际的排序会在qsort中进行

{

? ? if (? ((struct? stu*)e1)->sorce >?((struct? stu*)e2)->sorce? ) //e1e2是结构体类型，需要排序的是结构体类型

?? ?? ? return? 1;

? ? else? if(? ((struct? stu*)e1)->sorce < ((struct? stu*)e2)->sorce??)

?? ?? ? return? -1;

? ? else

?? ?? ? return? 0;

?? ?? ? //浮点数相减返回整型会出问题

}

void? print_stu(struct? stu arr[] , int sz)

{

? ? int i = 0;

? ? for(i = 0 ; i < sz ; i++)

? ? {

?? ?? ? printf("%s? %d? %f\n" , arr[i].name , arr[i].age , arr[i].sorce);

?? ?}

? ? printf("\n");

}

void? test1()

{

? ? struct? stu? arr[3] = {{"zhangsan" , 20 , 87.6f} , {"lisi" , 18 , 99.0f} , {"wangerma" , 16 , 60.0f}};

? ? int? sz = sizeof(arr) / sizeof(arr[0]);

?? ?qsort(arr , sz , sizeof(arr[0]) , cmp_struct_by_sorce); //按成绩排序

?? ?qsort(arr , sz , sizeof(arr[0]) , cmp_struct_by_age); //按年龄排序

?? ?qsort(arr , sz , sizeof(arr[0]) , cmp_struct_by_name); //按名字排序

? ? print_stu(arr , sz);

}

int? main()

{

? ? test1();

? ? return? 0;

}

qsort模拟——使用冒泡排序的逻辑，快速排序的算法

int cmp_int (const void* e1 , const void* e2) //比较e1，e2指向的数据

{

? ? if( *(int*)e1 >?*(int*)e2?)

?? ?? ? return? 1;

? ? else??if( *(int*)e1 <?*(int*)e2?)

?? ?? ? return? -1;

? ? else

? ? ?? ?return? 0;

}

void? swap(char* buf1 , char* buf2 , int width)

//因为不知道具体类型，只能通过char类型和width一字节一字节的交换

{

? ? int i = 0;

? ? for(i = 0; i < width; i++)

? ? {

?? ?? ? char tmp = *buf1;

?? ?? ? *buf1 = *buf2;

?? ?? ? *buf2 = tmp;

?? ?? ? buf1++;

?? ?? ? buf2++;

?? ?}

}

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

//上方e1e2可以省略，cmp是函数指针，e1e2不是需要传参的变量

{

? ? int i = 0;

? ? int j = 0;

?? ?for(i = 0; i < sz-1; i++)

? ? {

?? ?? ? for(j = 0; j < sz-i-1; j++)

?? ?? ? {

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

?? ??? ?? ? {

? ? ? ? ? ? ? ?swap( (char*)base + j*width , (char*)base + (j + 1)*width , width);

?? ??? ??? ?? ? //用char类型来计算具体类型的空间，因为char的空间最小，在通过width掌握交换的空间大小

?? ??? ?? ? }

?? ??? ?}

?? ?}

}

void print_bubble(int *p,int sz)

{

? ? int i = 0;

? ? for(i = 0; i < sz; i++)

? ? {

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

?? ?}

}

void test1()

{

? ? int sz = 0;

? ? int arr[10] = {9,8,7,6,5,4,3,2,1,0};

? ? sz = sizeof(arr)/sizeof(arr[0]);

? ? bubble_sort(arr,sz,sizeof(arr[0],cmp_int));

?? ? //cmp_int是比较方式，若想比较更多类型，还需要写不同类型的比较函数，从这个角度来看，qsort不是完全的通用排序。

? ? print_bubble(arr,sz);

? ? //打印方式也并非固定

}

int? main()

{

? ? test1();

? ? return? 0;

}