数组单元格大小不一致

Question

我正在做一个学校项目，在 C 代码中实现一些排序算法，我正在对一些通用数据类型 arrays 进行二进制插入排序（所以我使用void*项目和void**数组）。

我有一个binarySearch function 返回索引，我必须将一个项目插入数组以保留其元素的顺序（根据我传递给排序函数的给定 function），并且这可以正常工作。

int binary_search(void **arr, void *item, long start, long end, int data_size, compFunc compare)
{
  int s = start, e = end;
  while (s <= e)
  {
    long middle = s + (e - s) / 2;
    int comparison = compare(item, arr[middle]);
    if (comparison == 0)
      return middle;
    else if (comparison > 0)
      s = middle + 1;
    else
      e = middle - 1;
  }
  return s;
}

然后我有binaryInsertSort function

void binary_insert_sort(void **arr, long arr_size, int data_size, compFunc compare)
{
  long explored, j, pos;
  void *current = malloc(sizeof(void*)), *holder;
  if(!current){
    perror("Error allocating memory\n");
    exit(EXIT_FAILURE);
  }
  for (explored = 1; explored < arr_size; explored++)
  {
    memcpy(current, arr[explored], data_size);
    j = explored - 1;
    pos = binary_search(arr, current, 0, j, data_size, compare);
    while (j >= pos)
    {
      holder = malloc(sizeof(void *));
      memcpy(holder, (*arr) + (j + 1)*data_size, data_size);
//CRASHES HERE
      memcpy((*arr) + (j + 1) * data_size, (*arr) + (j * data_size), data_size);
      memcpy((*arr) + (j * data_size), holder, data_size);
      j--;
      free(holder);
    }
  }
  free(current);
}

我这样称呼这些功能

int main(int argc, char const *argv[])
{
    char* arr[] = {"a", "b", "f", "d", "c", "g", "e", "1"};
    int n = sizeof(arr)/sizeof(char*);

    binary_insert_sort((void**)arr, n, sizeof(char*), string_compare);
    print_string_array(arr, n);
    return 0;
}

但是当我尝试将arr[j+1]移动到arr[j]时，它总是在第一个memcpy之后崩溃； 我尝试进行一些调试，并且在尝试打印(int)(arr[1]-arr[0]) （如果我理解正确的话应该打印单元格的大小）之后，我注意到单元格的大小 = 2 而不是预期sizeof(char*)=4 ，因此在使用*arr + j*data_size时无法正确访问它们，因为我移动的是j * 2单元格而不是j

为什么会这样？

如果我遗漏了一些基本的东西，或者如果英语或格式不正确，我很抱歉，第一次问

Answer 1

由于 function 声明及其调用，您的方法最初是错误的

binary_insert_sort((void**)arr, n, sizeof(char*), string_compare);
                   ^^^^^^^^^^^  

也就是说，如果在 function 中，您将取消引用指针，例如

arr[explored]

那么表达式将具有类型void * 。 因此，如果原始数组具有例如类型

char arr[] = "hello";

那么在上面的表达式中将使用不正确的指针算法。 这不是像value of arr + explored * sizeof( char )的值那样评估指针表达式的值，而是像value of arr + explored * sizeof( void * )的值那样评估指针表达式的值。

function 也是低效的。 memory while循环分配过多

while (j >= pos)
{
  holder = malloc(sizeof(void *));
  //...

至少应声明 function

void binary_insert_sort( void *arr, size_t arr_size, size_t data_size, compFunc compare);

function binary_search有一个冗余参数start 。 您正在调用 function 始终传递 0 作为参数 start 的参数

pos = binary_search(arr, current, 0, j, data_size, compare);

代替参数start和end传递子数组中元素的数量就足够了。 所以 function 可以这样声明

int binary_search( const void *arr, const void *item, size_t arr_size, size_t data_size, compFunc compare);

或者类似于标准 C function bsearch like

int binary_search( const void *item, const void *arr, size_t arr_size, size_t data_size, compFunc compare);

如果子数组已经有等于搜索元素的元素，那么 function 应该返回子数组中存在元素之后的 position，而不是返回存在元素的 position。

Answer 2

我正在做一个学校项目，在 C 代码中实现一些排序算法，我正在对一些通用数据类型 arrays 进行二进制插入排序（所以我使用 void* 项目和 void** 数组）。

您在评论中澄清了您的意思是您想要一个 function 可以对具有任何元素类型的 arrays 进行排序。 这正是标准库的qsort() function 所做的，因此您应该查看它以获取有关 function 的外观和工作方式的指导。

特别是，您需要了解 C 没有通用数据类型。 特别是，一个void *可以指向任何类型的 object，但void *本身是一个特定的、完整的类型，在任何方面都不是通用的。 ^*因此，使用void * items 根本达不到你的目的。 即使你只想对 arrays 个指针进行排序，因为 C 语言不保证不同的指针类型具有相同的表示，甚至相同的大小，除了char *和void *需要具有相同的大小和表示。

换句话说，不，您没有void *项目，并且您不想对“ void **数组”进行排序。 因此，不，您的binarySearch() function 对于void *数组不符合您的目的 - 无论它的工作做得如何，它都是错误的工作。

在qsort()之后，这是一个可以满足您的目的的签名：

typedef int (*compFunc)(const void *, const void *);

void binary_insert_sort(void *arr, size_t element_count, size_t element_size,
        compFunc compare);

请注意，要排序的数组是通过指向其第一个元素的指针传送的，由 function 接收为void *类型的指针 - 而不是void ** 。 然而，这确实存在一个问题：您不能对void *执行指针算术或数组索引，因为这些操作是根据指向类型的大小定义的，在这种情况下这是未知的，因为void是一个不完整的类型. 但是出现这样的问题并不奇怪，因为整个练习的重点是在编译 function 时对大小未知的对象进行排序。

所以你会怎么做？ 传统的方法是通过转换为char * ：

#define ELEMENT_POINTER(base, index, size) ((char *) (base) + (index) * (size))

void *element_3_for_example = ELEMENT_POINTER(arr, 3, element_size);

所以比较看起来像这样......

int result = compare(ELEMENT_POINTER(arr, i, element_size),
                     ELEMENT_POINTER(arr, j, element_size));

...交换可能看起来像这样：

void *temp = malloc(element_size);

// ...

memcpy(temp, ELEMENT_POINTER(arr, i, element_size));
memcpy(ELEMENT_POINTER(arr, i, element_size), ELEMENT_POINTER(arr, j, element_size));
memcpy(ELEMENT_POINTER(arr, j, element_size), temp);

// ...

free(temp);

我将留给您根据这些或类似结构进行实际练习。

---

至于实际问题...

为什么会这样？

，这是因为你的 function 对数组的元素本身是被排序的项目还是指向被排序元素的指针感到困惑。 错误地假设后者，它做出了交换数据而不是指针的进一步有问题的选择。 在这种特殊情况下，数据毕竟是指针，尽管情况并非总是如此。 他们指向的数据是 arrays 包含字符串文字，和

1. 这些 arrays 不是预期的大小，因此您在读取和写入时都超出了范围，并且
2. 它们无论如何都是不可写的，这可能是错误的具体来源。

---

^*可以认为void是一种通用数据类型，因为确实可以采用此答案来证明。 但是您不能将 object 声明为void类型，也不能通过void类型的左值访问 object，因此这在很大程度上没有实际意义。

Answer 3

好的，多亏了之前评论的帮助，我设法让它有所进展，这是更新后的代码

#define GET_PTR(base, offset, size) ((char *)(base) + (offset) * (size))

long binary_search(void *arr, void *item, size_t end, int data_size, compFunc compare)
{
    long s = 0, e = end, middle;
    int comparison;
    while (s <= e)
    {
        middle = s + (e - s) / 2;
        comparison = compare(item, GET_PTR(arr, middle, data_size));
        if (comparison == 0)
            return middle;
        else if (comparison > 0)
            s = middle + 1;
        else
            e = middle - 1;
    }
    return s;
}

void swap(void *base, long ind1, long ind2, size_t data_size)
{
    void *temp = malloc(data_size);
    memcpy(temp, GET_PTR(base, ind2, data_size), data_size);
    memcpy(GET_PTR(base, ind2, data_size), GET_PTR(base, ind1, data_size), data_size);
    memcpy(GET_PTR(base, ind1, data_size), temp, data_size);
    free(temp);
}

void binary_insert_sort(void *arr, size_t arr_size, size_t data_size, compFunc cmp)
{
    void *current = malloc(data_size), *holder;
    long explored, shifting, bs_pos;
    for (explored = 1; explored < arr_size; explored++)
    {
        current = GET_PTR(arr, explored, data_size);
        shifting = explored - 1;
        bs_pos = binary_search(arr, current, shifting, data_size, cmp);

        while (shifting >= bs_pos)
        {
            swap(arr, shifting, shifting + 1, data_size);
            shifting--;
        }
    }
    free(current);
}

这似乎有效，当像这样调用时，它设法正确排序一个 int 数组和一个“Person”结构

int main(int argc, char const *argv[])
{
    // char *string_arr[] = {"a", "b", "f", "d", "c", "g", "e", "1"};
    // int char_size = sizeof(arr) / sizeof(arr[0]);
    // print_string_array((char**)arr, char_size);
    // binary_insert_sort((void*)arr, char_size, sizeof(char*), string_compare);
    // print_string_array((char**)arr, char_size);


    int int_arr[] = {5, 3, 2, 4, 0, 6, 14, -4, 0, 32, 2, -1};
    int int_size = sizeof(int_arr) / sizeof(int_arr[0]);
    print_int_array((int*)int_arr, int_size);
    binary_insert_sort((void*)int_arr, int_size, sizeof(int), int_compare);
    print_int_array((int*)int_arr, int_size);


    Person p_arr[] = {{3, "fabio"}, {5, "marco"}, {0, "giulio"}, {2, "alberto"}, {1, "gabri"}};
    int p_size = sizeof(p_arr)/sizeof(p_arr[0]);
    for(int i =0;i<p_size;i++) print_person(&(p_arr[i]));
    // binary_insert_sort(p_arr, p_size, sizeof(Person), person_int_cmp);
    binary_insert_sort(p_arr, p_size, sizeof(Person), person_string_cmp);
    for(int i =0;i<p_size;i++) print_person(&(p_arr[i]));

    return 0;
}

但由于某种原因，字符串数组只是不会排序：我放了一些调试打印，对我来说问题似乎是当我比较它们时，真正被比较的是它们的地址，因为 binary_search 中的comparison值总是 1当它排序char_arr

以下是正在使用的函数：

typedef struct {
int id;
char* name;
} Person;

int person_int_cmp(void* p1, void* p2)
{
Person *a = (Person*)p1;
Person *b = (Person*)p2;
return a->id - b->id;
}

int person_string_cmp(void* p1, void* p2)
{
Person *a = (Person*)p1;
Person *b = (Person*)p2;
return strcmp(a->name, b->name);
}

void print_person(void* p){
Person* a = (Person*)p;
printf("%d: %s\n", a->id, a->name);
}

int string_compare(void *a, void *b)
{
char * str1 = (char *)a;
char * str2 = (char *)b;
return strcmp(str1, str2);
}

int int_compare(void *n1, void *n2)
{
int n01 = *(int *)n1, n02 = *(int *)n2;
return n01 - n02;
}

void print_int_array(int *arr, long size)
{
printf("\t[");
for (int i = 0; i < size; i++) printf("%d -> ", arr[i]);
printf("]\n");
}

void print_string_array(char** arr, long size)
{
printf("\t[");
for (int i = 0; i < size; i++) printf("%s -> ", arr[i]);
printf("]");
}

我是否以某种我不知道的错误方式处理字符串数组？ 对我来说更奇怪的是，它能够按名称（字符串）正确地对 Person 数组进行排序，而不是仅由字符串组成的数组如果有人能指出我做错了什么，非常感谢