嵌套结构的C qsort数组

我正在尝试对结构记录数组进行排序。由于某种原因，堆芯转储不断发生

当我尝试用int或struct数组做同样的事情时，它工作得非常好。然而，当我开始使用嵌套结构时，它开始核心转储

电流输出为：

Before sorting
first last 0  
first last 1  
first last 2  
first last 3  
first last 4  
first last 5  

AFTER sorting  
Segmentation fault (core dumped)

编译器：Cygwin

typedef struct {
    char last[NAMESIZE]; /* last name (1 word) */
    char first[NAMESIZE]; /* first name (1 word) */
} name;

typedef struct {
    name name;
    int score; /* score (between 0 & 100 inclusive) */
} record;

int compare (const void * a, const void * b){
    const record *recordA = (record *)a;
    const record *recordB = (record *)b;
    printf("%d: %d", recordA->score, recordB->score);
    return ( recordB->score - recordA->score );
}

int main (){
    record ** list;
    int i;
    list=malloc(6*sizeof(record*));
    printf("Before sorting\n");
    for(i=0; i<6; i++){ 
        list[i]=malloc(sizeof(record));
        strcpy(list[i]->name.first,"first");
        strcpy(list[i]->name.last,"last");
        list[i]->score=i;   
    }
    for (i=0; i<6; i++){
        printf ("%s %s %d\n",list[i]->name.first, list[i]-    >name.last,list[i]->score);         
    }

    printf("AFTER sorting\n");
    qsort (list, 6, sizeof(record), compare);
    for (i=0; i<6; i++){
        printf ("%s %s %d\n",list[i]->name.first, list[i]- >name.last,list[i]->score);         
    }    
  return 0;
}

typedef结构{
char last[名称]；/*姓氏（1个单词）*/
char first[名称]；/*名字（1个单词）*/
}姓名；
类型定义结构{
姓名；
整数分数；/*分数（介于0和100之间）*/
}记录；
整数比较（常数无效*a，常数无效*b）{
常量记录*记录a=（记录*）a；
常量记录*recordB=（记录*）b；
printf（“%d:%d”，记录a->score，记录b->score）；
返回（recordB->score-recordA->score）；
}
int main（）{
记录**清单；
int i；
列表=malloc（6*sizeof（记录*）；
printf（“排序前”）；
对于（i=0；iname.first，“first”）；
strcpy（列表[i]->name.last，“last”）；
列表[i]->得分=i；
}
for（i=0；iname.first，list[i]>name.last，list[i]>score）；
}
printf（“排序后\n”）；
qsort（列表，6，大小（记录），比较）；
for（i=0；iname.first，list[i]>name.last，list[i]>score）；
}    
返回0；
}

列表

是一个由6个指针组成的数组，指向

记录

：

list=malloc（6*sizeof（记录*）

因此，您需要将相同的大小传递给
qsort

qsort（列表，6，大小（记录），比较）

应该是

qsort (list, 6, sizeof(record*), compare);

或者更好

qsort (list, 6, sizeof(*list), compare);

我同意第一个答案。但有一点很清楚，你不应该使用
qsort（list，6，sizeof（record），compare），其中sizeof（record）将返回记录的总字节数，但不会自动计算名称使用的字节数。
也没有
qsort（list，6，sizeof（record），compare），其中sizeof（record）将返回record*的4个字节，因为它是指针。
相反，我认为您可能只需要自己计算字节数，然后在数据结构记录中添加另一个数据，如namesize
如果您有两个记录的比较函数，您需要将它们分配给指向记录的常量指针

在您的qsort中，我猜您已经传入了记录列表数据结构，因此元素的数量将是您使用的

/*Comparison function: Score ascending only.*/
int cmp_sasc(const void *p, const void *q){
    record * const *pp = p;
    record * const *qq = q;
    return (*pp)->score - (*qq)->score;
}

代码中没有
struct record
数组。您有一个指向
struct record
的指针数组。这就是你要做的
qsort
。因此，代码中的所有其他内容都应该相应地重写。您对
qsort
的调用不正确。您的比较函数不正确。为什么需要将它们指定给指向记录的常量指针？将它们赋给比较函数中的一个指针，将void*强制转换为相应的指针，这难道不是重点吗？