为什么《算法技术手册》上的这段代码通不过编译？

[zansan]

《算法技术手册》p73上有段基于值的插入代码：
void sortValues(void *base,int n,int s,int(*cmp)(const void *, const void *)){
int j;
void *saved=malloc(s);

for(j=1;j<n;j++){
int i=j-1;
void *value=base+j*s;
if(i>=0 && cmp(base+i*s,value)>0){
i--;
}
if(++i==j) continue;
memmove(saved,value,s);
memmove(base+(i+1)*s,base+i*s,s*(j-i));
memmove(base+i*s,saved,s);
}
}
编译时报错： void *value=base+j*s;里的void *未知大小。为什么这里编译器计较起大小？

[jackyjkchen]

void *只能接受数据，无法通过加减号寻址的，因为一个void多大你知道么？你不知道，编译器也不知道……

他的意思应该是用byte大小寻址吧，那就强转成char*再寻址咯

[cattycat]

需要先做类型转换，看你的base是什么类型的，然后再转为void*

[ayw215]

yes，先强转一下

[chaoliu1024]

void *空指针不知道多大
好像我从来还没有用到空指针的
看看base的类型，然后转化下。。。

[cheng20100915]

类型转换问题,
楼上的几位说的有道理

[harizu76]

void也可以做数据类型吗.不懂的

[zhangweiit]

声明一个变量的时候，编译器要明白这个类型需要多大的空间
void *是很特殊的一个类型
一般只用来做指针类型的中间转换之类的用途

可以直接指向其它变量 ，但是，做+的操作，就不行了

[zansan]

我是按书上的代码抄下来的，在一些书里也提到VOID可以做无类型指针，
那段代码的本意是能接受所有类型的数组进行插入排序。难道是部分编译器支持这种用法。我用的是vs。得试下其他的编译器

[zhangweiit]

[Quote=引用 8 楼 zansan 的回复:]

我是按书上的代码抄下来的，在一些书里也提到VOID可以做无类型指针，
那段代码的本意是能接受所有类型的数组进行插入排序。难道是部分编译器支持这种用法。我用的是vs。得试下其他的编译器
[/Quote]

我个人的看法是，只要VS不支持的做法，我都不用
只是个人看法啦，毕竟我工作要用VS

也有很多人的工作压根不需要VS，他们有专门的平台，编译器不一样

[jackyjkchen]

[Quote=引用 8 楼 zansan 的回复:]
我是按书上的代码抄下来的，在一些书里也提到VOID可以做无类型指针，
那段代码的本意是能接受所有类型的数组进行插入排序。难道是部分编译器支持这种用法。我用的是vs。得试下其他的编译器
[/Quote]
不是VC不支持，而是实现根本有问题，看看人家微软的qsort怎么做的……也是任意类型排序

void __fileDECL qsort (
    void *base,
    size_t num,
    size_t width,
    int (__fileDECL *comp)(const void *, const void *)
    )
{
    char *lo, *hi;              /* ends of sub-array currently sorting */
    char *mid;                  /* points to middle of subarray */
    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 */

    stkptr = 0;                 /* initialize stack */

    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:

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

        /* 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. */

            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.*/

        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 */
}

[jackyjkchen]

lo = (char *)base;
hi = (char *)base + width * (num-1);
注意这两句，发现问题了么？

[ForestDB]

需要把void*转成具体的类型。

[zansan]

感谢大家的支持，我换到MinGW 就通过了。微软的做法也让人大开眼界