在windows下看了qsort的源代码，想了下用户自己写的comp会在调用库的后面，而测试发现Linux下的，带有函数指针参数的函数可以位于所引用的函数的前面
//文件名为 s.c 编译compile 运行run
//compile: gcc s.c
//run: ./a.out
//function:函数中参数带有函数指针，而对应函数指针可以在该函数的后面
#include<stdio.h>
//参数中带有函数指针的函数
void fun_p(int x,int(*fp)(int))//(int)(*fp)(int)返回值多了括号会报错
{
if(fp(x)<0)printf("fp return <0\n");
}
//函数指针的函数
int func(int m)
{
printf("%d\n",m);
return -1;
}
int main(int argc,char*argv[])
{
fun_p(2,func);
return 0;
}
qsort被稍微注释的源代码
/***
*qsort.c - quicksort algorithm; qsort() library function for sorting arrays
*
* Copyright (c) Microsoft Corporation. All rights reserved.
*
*Purpose:
* To implement the qsort() routine for sorting arrays.
*
*******************************************************************************/
#include <stdlib.h>
#include <search.h>
#include <internal.h>
/* Always compile this module for speed, not size */
#pragma optimize("t", on)
//https://msdn.microsoft.com/zh-cn/library/ec7sfckb.aspx
#if defined (_M_CEE)
#define __fileDECL __clrcall
#else /* defined (_M_CEE) */
#define __fileDECL __cdecl //所有参数从右到左依次入栈
#endif /* defined (_M_CEE) */
/* when building Managed Run time dll, we should be defining __cdecl
* to __clrcall. Also note that when compiling for MRT, we are compiling
* as C++ file.
*/
/* prototypes for local routines *///shortsort函数声明用于width-单个元素小于等于一字节比较使用
#ifdef __USE_CONTEXT
static void __fileDECL shortsort_s(char *lo, char *hi, size_t width,
int (__fileDECL *comp)(void *, const void *, const void *), void *);
#define swap swap_c
#else /* __USE_CONTEXT */
static void __fileDECL shortsort(char *lo, char *hi, size_t width,
int (__fileDECL *comp)(const void *, const void *));
#endif /* __USE_CONTEXT */
static void __fileDECL swap(char *p, char *q, size_t width);//交换声明
/* this parameter defines the cutoff between using quick sort and
insertion sort for arrays; arrays with lengths shorter or equal to the
below value use insertion sort */
#define CUTOFF 8 /* testing shows that this is good value *///使用shorsort函数的限定一字节=8bit
/* Note: the theoretical number of stack entries required is
no more than 1 + log2(num). But we switch to insertion
sort for CUTOFF elements or less, so we really only need
1 + log2(num) - log2(CUTOFF) stack entries. For a CUTOFF
of 8, that means we need no more than 30 stack entries for
32 bit platforms, and 62 for 64-bit platforms. */
#define STKSIZ (8*sizeof(void*) - 2)//sizeof(void*)获取地址字节数，16位-2；32位-4；64位-8；
/***
*qsort(base, num, wid, comp) - quicksort function for sorting arrays
*
*Purpose:
* quicksort the array of elements
* side effects: sorts in place
* maximum array size is number of elements times size of elements,
* but is limited by the virtual address space of the processor
*
*Entry:
* char *base = pointer to base of array
* size_t num = number of elements in the array
* size_t width = width in bytes of each array element
* int (*comp)() = pointer to function returning analog of strcmp for
* strings, but supplied by user for comparing the array elements.
* it accepts 2 pointers to elements.
* Returns neg if 1<2, 0 if 1=2, pos if 1>2.
*
*Exit:
* returns void
*
*Exceptions:
* Input parameters are validated. Refer to the validation section of the function.
*
*******************************************************************************/
#ifdef __USE_CONTEXT
#define __COMPARE(context, p1, p2) comp(context, p1, p2)
#define __SHORTSORT(lo, hi, width, comp, context) shortsort_s(lo, hi, width, comp, context);
#else /* __USE_CONTEXT */
#define __COMPARE(context, p1, p2) comp(p1, p2)
#define __SHORTSORT(lo, hi, width, comp, context) shortsort(lo, hi, width, comp);
#endif /* __USE_CONTEXT */
//qsort头选择+函数体
SECURITYSAFECRITICAL_ATTRIBUTE
#ifdef __USE_CONTEXT
void __fileDECL qsort_s (
void *base,
size_t num,
size_t width,
int (__fileDECL *comp)(void *, const void *, const void *),
void *context
)
#else /* __USE_CONTEXT */
void __fileDECL qsort (
void *base,
size_t num,
size_t width,
int (__fileDECL *comp)(const void *, const void *)
)
#endif /* __USE_CONTEXT */
{
char *lo, *hi; /* ends of sub-array currently sorting *///lo头/低地址，hi尾/高地址
char *mid; /* points to middle of subarray *///mid中间地址
char *loguy, *higuy; /* traveling pointers for partition step *///快排头尾移动指针
size_t size; /* size of the sub-array *///子段大小
char *lostk[STKSIZ], *histk[STKSIZ];//指针组堆栈存放未排子段头尾地址指针
int stkptr; /* stack for saving sub-array to be processed *///堆栈子段个数
/* validation section */
_VALIDATE_RETURN_VOID(base != NULL || num == 0, EINVAL);
_VALIDATE_RETURN_VOID(width > 0, EINVAL);
_VALIDATE_RETURN_VOID(comp != NULL, EINVAL);
if (num < 2)
return; /* nothing to do */// num<=1
stkptr = 0; /* initialize stack *///初始化指针组堆栈个数为0
lo = (char *)base;
hi = (char *)base + width * (num-1); /* initialize limits */
/* this entry point is for pseudo-recursion calling: setting
lo and hi and jumping to here is like recursion, but stkptr is
preserved, locals aren't, so we preserve stuff on the stack */
recurse://循环标签 下面用goto recurse 执行该qsort或者shortsort
size = (hi - lo) / width + 1; /* number of el's to sort */
/* below a certain size, it is faster to use a O(n^2) sorting method */
if (size <= CUTOFF) {
__SHORTSORT(lo, hi, width, comp, context);//小于等于CUTOFF=8bit（一字节）用shortsort比较
}
else {
/* First we pick a partitioning element. The efficiency of the
algorithm demands that we find one that is approximately the median
of the values, but also that we select one fast. We choose the
median of the first, middle, and last elements, to avoid bad
performance in the face of already sorted data, or data that is made
up of multiple sorted runs appended together. Testing shows that a
median-of-three algorithm provides better performance than simply
picking the middle element for the latter case. */
mid = lo + (size / 2) * width; /* find middle element *///取中间元素地址
/* Sort the first, middle, last elements into order */
if (__COMPARE(context, lo, mid) > 0) {
swap(lo, mid, width);
}
if (__COMPARE(context, lo, hi) > 0) {
swap(lo, hi, width);
}
if (__COMPARE(context, mid, hi) > 0) {
swap(mid, hi, width);
}
//两两比较获得lo mid hi 中存放的元素的值根据规则排序
/* We now wish to partition the array into three pieces, one consisting
of elements <= partition element, one of elements equal to the
partition element, and one of elements > than it. This is done
below; comments indicate conditions established at every step. */
loguy = lo;
higuy = hi;
/* Note that higuy decreases and loguy increases on every iteration,
so loop must terminate. */
for (;;) {
/* lo <= loguy < hi, lo < higuy <= hi,
A[i] <= A[mid] for lo <= i <= loguy,
A[i] > A[mid] for higuy <= i < hi,
A[hi] >= A[mid] */
/* The doubled loop is to avoid calling comp(mid,mid), since some
existing comparison funcs don't work when passed the same
value for both pointers. */
//以mid存放的元素为基准
if (mid > loguy) {
do {
loguy += width;
} while (loguy < mid && __COMPARE(context, loguy, mid) <= 0);
}
if (mid <= loguy) {
do {
loguy += width;
} while (loguy <= hi && __COMPARE(context, loguy, mid) <= 0);
}
/* lo < loguy <= hi+1, A[i] <= A[mid] for lo <= i < loguy,
either loguy > hi or A[loguy] > A[mid] */
do {
higuy -= width;
} while (higuy > mid && __COMPARE(context, higuy, mid) > 0);
/* lo <= higuy < hi, A[i] > A[mid] for higuy < i < hi,
either higuy == lo or A[higuy] <= A[mid] */
if (higuy < loguy)
break;
/* if loguy > hi or higuy == lo, then we would have exited, so
A[loguy] > A[mid], A[higuy] <= A[mid],
loguy <= hi, higuy > lo */
swap(loguy, higuy, width);
/* If the partition element was moved, follow it. Only need
to check for mid == higuy, since before the swap,
A[loguy] > A[mid] implies loguy != mid. */
if (mid == higuy)
mid = loguy;
/* A[loguy] <= A[mid], A[higuy] > A[mid]; so condition at top
of loop is re-established */
}
/* A[i] <= A[mid] for lo <= i < loguy,
A[i] > A[mid] for higuy < i < hi,
A[hi] >= A[mid]
higuy < loguy
implying:
higuy == loguy-1
or higuy == hi - 1, loguy == hi + 1, A[hi] == A[mid] */
/* Find adjacent elements equal to the partition element. The
doubled loop is to avoid calling comp(mid,mid), since some
existing comparison funcs don't work when passed the same value
for both pointers. */
higuy += width;
if (mid < higuy) {
do {
higuy -= width;
} while (higuy > mid && __COMPARE(context, higuy, mid) == 0);
}
if (mid >= higuy) {
do {
higuy -= width;
} while (higuy > lo && __COMPARE(context, higuy, mid) == 0);
}
/* OK, now we have the following:
higuy < loguy
lo <= higuy <= hi
A[i] <= A[mid] for lo <= i <= higuy
A[i] == A[mid] for higuy < i < loguy
A[i] > A[mid] for loguy <= i < hi
A[hi] >= A[mid] */
/* We've finished the partition, now we want to sort the subarrays
[lo, higuy] and [loguy, hi].
We do the smaller one first to minimize stack usage.
We only sort arrays of length 2 or more.*/
//先排个数多的子段，个数少的压入指针组栈lostk和histk
if ( higuy - lo >= hi - loguy ) {
if (lo < higuy) {
lostk[stkptr] = lo;
histk[stkptr] = higuy;
++stkptr;
} /* save big recursion for later */
if (loguy < hi) {
lo = loguy;
goto recurse; /* do small recursion */
}
}
else {
if (loguy < hi) {
lostk[stkptr] = loguy;
histk[stkptr] = hi;
++stkptr; /* save big recursion for later */
}
if (lo < higuy) {
hi = higuy;
goto recurse; /* do small recursion */
}
}
}
/* We have sorted the array, except for any pending sorts on the stack.
Check if there are any, and do them. */
//继续排头尾标志在堆栈中的子段
--stkptr;
if (stkptr >= 0) {
lo = lostk[stkptr];
hi = histk[stkptr];
goto recurse; /* pop subarray from stack */
}
else
return; /* all subarrays done */
}
/***
*shortsort(hi, lo, width, comp) - insertion sort for sorting short arrays
*shortsort_s(hi, lo, width, comp, context) - insertion sort for sorting short arrays
*
*Purpose:
* sorts the sub-array of elements between lo and hi (inclusive)
* side effects: sorts in place
* assumes that lo < hi
*
*Entry:
* char *lo = pointer to low element to sort
* char *hi = pointer to high element to sort
* size_t width = width in bytes of each array element
* int (*comp)() = pointer to function returning analog of strcmp for
* strings, but supplied by user for comparing the array elements.
* it accepts 2 pointers to elements, together with a pointer to a context
* (if present). Returns neg if 1<2, 0 if 1=2, pos if 1>2.
* void *context - pointer to the context in which the function is
* called. This context is passed to the comparison function.
*
*Exit:
* returns void
*
*Exceptions:
*
*******************************************************************************/
SECURITYSAFECRITICAL_ATTRIBUTE
#ifdef __USE_CONTEXT
static void __fileDECL shortsort_s (
char *lo,
char *hi,
size_t width,
int (__fileDECL *comp)(void *, const void *, const void *),
void * context
)
#else /* __USE_CONTEXT */
static void __fileDECL shortsort (
char *lo,
char *hi,
size_t width,
int (__fileDECL *comp)(const void *, const void *)
)
#endif /* __USE_CONTEXT */
{
char *p, *max;
/* Note: in assertions below, i and j are alway inside original bound of
array to sort. */
//选择排序
while (hi > lo) {
/* A[i] <= A[j] for i <= j, j > hi */
max = lo;
for (p = lo+width; p <= hi; p += width) {
/* A[i] <= A[max] for lo <= i < p */
if (__COMPARE(context, p, max) > 0) {
max = p;
}
/* A[i] <= A[max] for lo <= i <= p */
}
/* A[i] <= A[max] for lo <= i <= hi */
swap(max, hi, width);
/* A[i] <= A[hi] for i <= hi, so A[i] <= A[j] for i <= j, j >= hi */
hi -= width;
/* A[i] <= A[j] for i <= j, j > hi, loop top condition established */
}
/* A[i] <= A[j] for i <= j, j > lo, which implies A[i] <= A[j] for i < j,
so array is sorted */
}
/***
*swap(a, b, width) - swap two elements
*
*Purpose:
* swaps the two array elements of size width
*
*Entry:
* char *a, *b = pointer to two elements to swap
* size_t width = width in bytes of each array element
*
*Exit:
* returns void
*
*Exceptions:
*
*******************************************************************************/
SECURITYSAFECRITICAL_ATTRIBUTE
static void __fileDECL swap (
char *a,
char *b,
size_t width
)
{
char tmp;
if ( a != b )//a和b的地址不一样
/* Do the swap one character at a time to avoid potential alignment
problems. */
while ( width-- ) {//地址a和地址b中的一个字节一个字节的交换
tmp = *a;
*a++ = *b;
*b++ = tmp;
}
}
//取消宏定义
#undef __fileDECL
#undef __COMPARE
#undef __SHORTSORT
#undef swap
