c 中的 qsort 类型转换指针

Question

这是在 C 中练习 qsort 函数的简单代码。

int compareF(const void *a, const void *b) {
    // return (*(int**)a)[0] - (*(int**)b)[0];  
    const int *pr1 = *(const int **)a;
    const int *pr2 = *(const int **)b;
    return pr1[0] - pr2[0];
}

int main() {
    int *array[] = {(int[]){2,2,3}, (int[]){1,2,1},(int[]){1,3,3},(int[]){0,2,3},(int[]){1,2,0}};
    qsort(array, 5, sizeof(int[3]), compareF);
    for (int i = 0; i < 5; i++) {
        for (int j = 0; j < 3; j++) {
            printf("%d ", array[i][j]);
        }
        printf("\n");
    }
  return (0);
}

我不明白第 3 行和第 4 行为什么用指针以这种方式进行类型转换。这是我的理解。首先，无论我们是否设置新变量来保存参数，我们如何使用语法并不重要，因为这两个返回状态是相同的。 其次，它需要进行类型区分，因为参数是 void 类型，因此函数不知道类型。第一个 * 用于解引用参数 a，以便它可以访问地址 a。我们使用 int** 因为..？

main 函数中有一个二维整数数组。根据我的理解，CompareF 函数每次仅将 array[0] 和 array[1] 作为参数。所以我不明白为什么它用两个 ** 键入。

相同的代码只修改了一行代码

int array[3][2]= {{1,4},{3,6},{2,8}};

当以这种方式定义数组时，

const int *pr1 = *(const int[])a;
const int *pr2 = *(const int[])b;

，类型转换是否以相同的方式发生？或者

const int *pr1 = (const int*)a;
const int *pr2 = (const int*)b;

第一种情况不起作用，而第二种情况则有效。但不需要 * 来取消引用吗？喜欢

const int *pr1 = *(const int*)a;
const int *pr2 = *(const int*)b;

Answer 1

每当要比较任何两个数组元素时，都会调用传递给 qsort 的比较函数，并且它会获取每个数组元素的地址。

您有一个正在排序的 int * 数组，因此每个元素的地址都具有 int ** 类型。这与 compareF 的参数转换为的类型相匹配。取消引用这些指针会得到一个 int * 类型的值，这就是数组中实际包含的值。

另外，qsort 的第三个参数不正确。数组元素的类型不是 int[2]，而是 int * 类型。如果 int 是 4 个字节，而指针是 8 个字节，那么它们恰好是相同的，但您不能依赖于此。

Answer 2

对于初学者来说，qsort: 的调用

qsort(array, 5, sizeof(int[2]), compareF);

是不正确的。第三个参数是数组元素的大小。由于数组元素的类型为 int *，因此第三个参数必须为 sizeof( int * ) 或相同的 sizeof( *array )< /code>：

qsort(array, 5, sizeof( *array ), compareF);

函数qsort 将指向数组元素的指针作为const void * 类型的指针传递给比较函数compareF。

如果数组的元素类型为 int *，则指向数组元素的指针的类型为 int **。

因此，在函数compareF中，您需要将const void *类型的指针转​​换为const int **类型。取消引用这样的指针：

const int *pr1 = *(const int **)a;

您将获得原始数组的一个元素。

由于数组的元素指向类型为 int[3] 的复合文字的第一个元素，因此，例如比较函数中的表达式 pr1[0] 给出：复合文字的第一个元素，表达式 pr1[1] 给出复合文字的第二个元素，依此类推。

一般来说，使用此 return 语句：

return pr1[0] - pr2[0];

是不正确的，因为所提供的表达式可能会导致有符号整数类型 int 溢出。

比较复合文字的所有元素对原始数组的元素（指向复合文字的第一个元素的指针）进行排序更有趣。

这是一个演示程序：

#include <stdio.h>
#include <stdlib.h>

enum { M = 3 };

int compareF( const void *a, const void *b ) 
{
    const int *pr1 = *( const int ** )a;
    const int *pr2 = *( const int ** )b;
    
    size_t i = 0;
    while ( i != M && pr1[i] == pr2[i] ) ++i;
    
    return i == M ? 0 : ( pr2[i] < pr1[i] ) - ( pr1[i] < pr2[i] );
}

int main(void) 
{
    int * array[] = 
    {
        (int[M]){2,2,3}, 
        (int[M]){1,2,1},
        (int[M]){1,3,3},
        (int[M]){0,2,3},
        (int[M]){1,2,0}
    };
    
    const size_t N = sizeof( array ) / sizeof( *array );
    
    qsort( array, N, sizeof( *array ), compareF );
    
    for ( size_t i = 0; i < N; i++ )
    {
        for ( size_t j = 0; j < M; j++ )
        {
            printf( "%d ", array[i][j] );
        }
        
        putchar( '\n' );
    }
}

程序输出如下

0 2 3 
1 2 0 
1 2 1 
1 3 3 
2 2 3 

正如您所看到的，如果两个复合文字的第一个元素彼此相等，则比较第二个元素，依此类推。

如果您有一个像这样声明的二维数组

int array[3][2]= {{1,4},{3,6},{2,8}};

，则意味着元素类型又是数组类型int[2]。因此函数调用将类似于 指向

qsort(array, sizeof( array ) / sizeof( *array ), sizeof( int[2] ), compareF);

数组元素的指针将具有 int ( * )[2] 类型。
因此，在比较函数中取消引用指针，您将获得一个 int[2] 类型的数组（原始数组的一个元素），用作表达式的数组将隐式转换为指向其第一个元素的指针。

这是一个演示程序。

#include <stdio.h>
#include <stdlib.h>

enum { M = 2 };

int compareF( const void *a, const void *b ) 
{
    const int *pr1 = *( const int ( * )[M] )a;
    const int *pr2 = *( const int ( * )[M] )b;
    
    size_t i = 0;
    while ( i != M && pr1[i] == pr2[i] ) ++i;
    
    return i == M ? 0 : ( pr2[i] < pr1[i] ) - ( pr1[i] < pr2[i] );
}

int main(void) 
{
    int array[][M] = 
    {
        { 1, 4 }, { 3, 6 }, { 2, 8 }
    };
    
    const size_t N = sizeof( array ) / sizeof( *array );
    
    qsort( array, N, sizeof( *array ), compareF );
    
    for ( size_t i = 0; i < N; i++ )
    {
        for ( size_t j = 0; j < M; j++ )
        {
            printf( "%d ", array[i][j] );
        }
        
        putchar( '\n' );
    }
}

程序输出为：

1 4 
2 8 
3 6 

注意，当两个比较元素相等时，比较函数应返回0。相对于函数compareF，这意味着循环之后：

    size_t i = 0;
    while ( i != M && pr1[i] == pr2[i] ) ++i;

i将等于M，因为比较的一维数组的所有元素都是彼此平等。