Question

我正在尝试在C中对任意类型的数组进行排序。我正在使用指向空洞和memcpy的指针。但是，我一直在收到错误，说“无效使用无效表达式”＃39;与memcopy函数相关联，并且＆＃39;无效解除引用void指针＆＃39;。我知道有很多关于这个错误的其他线程，但阅读这些线程并没有帮助我解决这个问题。我的代码如下：

#include "mysort.h"
#include <alloca.h>
#include <assert.h>
#include <string.h>
#include <stdlib.h>

void mysort(int n, int elementSize, void * array, int ascending,CompareFunction compFunc)
{
    //bubblesort algorithm
    if (ascending == 1) 
    {   int c,d;
        void * swap = malloc(elementSize);
        void * thing1 = malloc(elementSize);
        void * thing2 = malloc(elementSize);

        for (c = 0; c < (n - 1); c++)
        {
            for (d = 0; d < n - c - 1; d++)
            {
                memcpy(thing1, array[d], elementSize);
                memcpy(thing2, array[d+1], elementSize);
                if ( compFunc(thing1,thing2) >= 0) 
                    {
                        memcpy(swap, array[d], elementSize);
                        array[d] = array[d+1];
                        array[d+1]= swap;
                    }
            }
        }
    }   


    if (ascending != 1) 
    {   int c,d;
        void * swap = malloc(elementSize);
        void * thing1 = malloc(elementSize);
        void * thing2 = malloc(elementSize);

        for (c = 0; c < (n - 1); c++)
        {
            for (d = 0; d < n - c - 1; d++)
            {
                memcpy(thing1, array[d], elementSize);
                memcpy(thing2, array[d+1], elementSize);
                if ( compFunc(thing1,thing2) <= 0) 
                    {
                        memcpy(swap, array[d], elementSize);
                        array[d] = array[d+1];
                        array[d+1]= swap;
                    }
            }
        }
    }   
}

非常感谢任何建议。

Answer 1

您不能像使用已知类型的数组那样在void *上使用数组下标运算符。你需要转换为char *并自己做指针算法。

此外，您不需要thing1和thing2。只需直接在要比较的元素上调用compFunc即可。

所以改变这个：

            memcpy(thing1, array[d], elementSize);
            memcpy(thing2, array[d+1], elementSize);
            if ( compFunc(thing1,thing2) >= 0) 
                {
                    memcpy(swap, array[d], elementSize);
                    array[d] = array[d+1];
                    array[d+1]= swap;
                }

对此：

            void *current = (char *)array + (elementSize * d);
            void *next = (char *)array + (elementSize * (d + 1));
            if ( compFunc(current, next) >= 0)
                {
                    memcpy(swap, current, elementSize);
                    memcpy(current, next, elementSize);
                    memcpy(next, swap, elementSize);
                }

同样在另一种情况下。

Answer 2

正如评论中所述，编译器抱怨array[d]和array[d + 1]。参数array是void *，因此如果这些表达式有效，那么他们将指定void类型的对象，这些对象不可存在。

然而，这只是潜在问题的症状。您不希望首先将数组元素传递给memcpy()。相反，您希望将指针传递给它们。表达这些的最好方法可能是通过指针算法。例如：

memcpy(thing1, ((char *) array) + (d * elementSize), elementSize);

在仲裁排序中使用memcpy无效表达void表达式

2 个答案: