C 确定要在qsort中使用的结构中每个元素的大小

我想知道传递给qsort的

code

结构中每个元素的大小是否由

sizeof（code）

或

sizeof（code*）

决定。这两种方法似乎都管用。同样适用于

malloc（sizeof（Emp*））

或

malloc（sizeof（Emp））

我在这个排序算法上做错什么了吗

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

typedef struct CODE{
    void *ecode;
} Code;

typedef struct EMP{
    Code *codes;
    int total;
} Emp;

int *decptr(int n){
    int *p = malloc(sizeof(int));
    *p = n;
    return p;
}   

int orderEmp(const void *p1, const void *p2){
    const Code *q1 = p1;
    const Code *q2 = p2; 
    int r = (*(int *) q1->ecode);
    int s = (*(int *) q2->ecode); 

    return (r<s)-(r>s);
}   

Emp *sortEmp(Emp *employee, int total){
    // sizeof(Code) vs sizeof(Code*)?
    qsort(employee->codes, total, sizeof(Code), orderEmp);  
}   

#define NUM 20
int main(){
    int i; 
    // sizeof(Emp) vs sizeof(Emp *)?
    Emp *employee = malloc(sizeof(Emp));
    employee->total = 0;
    // sizeof(Code) vs sizeof(Code *)?
    employee->codes = calloc(NUM, sizeof(Code));

    for(i = 0; i < NUM; i++){
        employee->codes[i].ecode = decptr(i);
        employee->total++;
    }   

    sortEmp(employee, employee->total);

    for(i = 0; i < NUM; i++){
        printf("%d\n", (*(int *) employee->codes[i].ecode));
    }   

    return 0;
}   

#包括
#包括
类型定义结构代码{
void*ecode；
}代码；
类型定义结构EMP{
代码*代码；
整数合计；
}环境管理计划；
int*decptr（int n）{
int*p=malloc（sizeof（int））；
*p=n；
返回p；
}   
int orderEmp（常数无效*p1，常数无效*p2）{
常数代码*q1=p1；
常量代码*q2=p2；
INTR=（*（int*）q1->ecode）；
INTS=（*（int*）q2->ecode）；
返回（rs）；
}   
Emp*sortEmp（Emp*员工，整数合计）{
//sizeof（代码）与sizeof（代码*）？
qsort（员工->代码、总计、sizeof（代码）、orderEmp）；
}   
#定义数字20
int main（）{
int i；
//sizeof（Emp）与sizeof（Emp*）？
Emp*员工=malloc（sizeof（Emp））；
员工->总计=0；
//sizeof（代码）与sizeof（代码*）？
员工->代码=calloc（NUM，sizeof（代码））；
对于（i=0；i代码[i]。ecode=decptr（i）；
员工->总计++；
}   
sortEmp（员工，员工->总计）；
对于（i=0；icode[i].ecode））；
}   
返回0；
}   

使用

qsort（员工->代码，总计，sizeof*（员工->代码），orderEmp）并避免使用错误的大小。与
employee=malloc（sizeof*employee）相同谢谢，你能详细说明一下这和贴出来的有什么不同吗？当我回顾
qsort（employee->code，total，sizeof（code），orderEmp）时，它将如何打破并知道
employee->code
是指向某个对象的指针。要获得正确的大小，只需
sizeof*（employee->code）
而不是
sizeof（code）
。我不需要知道它指向的类型。不易出错。也许明天，
employee->code
将成为指向新类型的指针。通过这种方式，
qsort（）
调用不需要更改。由于
sizeof（code）==sizeof（void*）
和
sizeof（code*）==sizeof（void*）
，您可以在这种非常特殊的情况下使用这两种方法中的任何一种。一般来说，你需要指定结构的大小-
sizeof（code）
，而不是指针的大小，除非你是在对指针数组而不是结构数组进行排序。换句话说，这次你很幸运，不要碰运气——听从@chux的建议…使用
qsort（employee->code，total，sizeof*（员工->代码，orderEmp）；
并避免使用错误的大小。与
employee=malloc（sizeof*employee）相同；
谢谢，您能详细说明这与发布的不同之处吗？它将如何中断，segfult？当我查看
qsort（员工->代码，总计，sizeof（代码），orderEmp时）
并知道
employee->code
是指向某物的指针。要获得正确的大小，只需
sizeof*（employee->code）
而不是
sizeof（code）
。我不需要知道它指向的类型。不太容易出错。也许明天，
employee->code
将成为指向新类型的指针。这样，
qsort（）
调用不需要更改。因为
sizeof（code）=sizeof（void*）
和
sizeof（code*）==sizeof（void*）
，在这种相当特殊的情况下，您可以不使用任何一种。通常，您需要指定结构的大小-
sizeof（code）
-而不是指针的大小，除非你是在对指针数组而不是结构数组进行排序。换句话说，这次你很幸运，不要碰运气——听从@chux的建议。。。