需要帮助将结构数组更改为结构数组

Question

我有以下工作代码。但是，我误读了指令并制作了一个包含数组的结构，而不是结构数组。

下面是来自数组结构的工作代码。下面是我认为我对将其更改为结构数组的理解，这可能是错误的。我还需要弄清楚在最后打印时如何对输入的学生 ID 进行排序，但这并不重要。感谢您的帮助！

#include <stdio.h>

struct student {
    int studID;
    int marks[100];
    };

int main() {

    struct student s[100];
    int i, j, val, flag=0;

    printf(" \n Please enter the students ID# followed by their grades. When done entering\n");
    printf(" grades, enter 101 to start a new student or 102 to exit entry.\n\n\n ");

    for(i=0;i<10;) {

        printf("Enter student ID#: ");
        scanf("%d",&s[i].studID);

        printf("\nFor student ID# %d\n",s[i].studID);

        for(j=0;j<100;j++) {
            printf("Enter grades: ");
            scanf("%d",&val);

            if(val>=0 && val<=100) {
                s[i].marks[j]=val;
                }
            else if(val==101) {
                s[i].marks[j]=-1;
                break;
                }
            else if(val==102) {
                s[i].marks[j]=-1;
                flag=1;
                break;
                }
            else {
                printf("\ninvalid entry\n");
                j--;
                }
            }

        printf("\n\n----------\n\n");

        i++;

        if(flag==1)
            break;
        }

    int num=i;

    for(i=0; i<num ; i++) {
        printf("\nInformation for student ID number %d:\n",s[i].studID);
        for(j=0; s[i].marks[j]!=-1; j++)
        printf("Grades: %d\n",s[i].marks[j]);
        }

    return 0;
 }

我认为我需要做的是

struct student {
    int studID;
    int marks;  //remove the array from marks
    };

int main() {

    struct student s[100];
    struct student m[100];  //maybe add this second array?

我不确定在那之后该去哪里。如果我从结构中的标记中删除数组，s[i].marks[j] 的任何位置都会出现错误“下标值既不是数组也不是指针也不是向量”。任何有关如何解决这个问题的帮助将不胜感激。

Answer 1

误读指令并创建了一个包含数组的结构，而不是结构数组

简单的答案是

不，结构数组可以由具有数组作为其成员的结构或数组结构组成

在您的代码中为以下结构：

struct student  //this is a structure of array
{
    int studID;
    int marks[100];
};

struct student s[100] 绝对是一个结构数组。所以你没有按照说明做任何事情，你的第一个代码确实是结构数组的实现:)

但是，如果不允许使用数组作为结构成员，请阅读其余答案。

---

不使用数组结构实现：

问题： （用你的方法）

struct student
{
   int studID;
   int marks; //you made array to a single variable
};

• 好吧，您已经删除了结构内部的数组，但是，正如您所提到的：现在您无法访问 s[i].marks[j] 因为现在 marks 是一个保存单个整数的变量，它不能通过使用像s[i].marks[index] 这样的索引来存储多个值

解决方案：

• 如果您的目标只是避免使用数组作为结构成员，并且如果您想访问marks 并使用下标存储它，那么您可以将marks 声明为指针使用 malloc() 函数 (include stdlib.h file) 到动态分配内存的基地址，如下所示：

  struct student
  {
     int studID;
     int *marks;
  };
  //so now in this structure there is no array, 
  //you just have a integer and integer pointer as members 
  

• 然后，在第一个 for 循环中，添加：

  for(i=0;i<10;) 
  {
  
      printf("Enter student ID#: ");
      scanf("%d",&s[i].studID);
  
      s[i].marks = malloc(100*sizeof(int)); //here you are allocating memory
  

• 您正在为要输入的100 等级分配内存。现在，如果用户只是为学生输入10 成绩，那么为90 更多成绩分配的剩余内存将被浪费。您可以通过将s[i].marks 的大小重新分配给足够数量的等级来避免这种情况

  • 当用户输入101时，它标志着当前student的成绩/分数结束，所以你可以这样重新分配：

    else if(val==101)
    {
        s[i].marks[j]=-1;
        s[i].marks = realloc(s[i].marks,(j+1)*sizeof(int)); //resize
        break;
    }  
    //`(j+1)*sizeof(int)` because there are `j` number of grades
    //and an additional `-1` to mark the end of array.
    

  • 同样，当您输入102 时，您可以这样调整s[i].marks 的大小：

     else if(val==102)
    {
        s[i].marks[j]=-1;
        s[i].marks = realloc(s[i].marks,(j+1)*sizeof(int)); //resize
        flag=1;
        break;
     }
    

• 现在您可以使用s[i].marks[j]访问元素

• 最后不要忘记以这种方式使用free() 函数释放分配的内存：

  for(i=0; i<num ; i++)
  {
      free(s[i].marks);
  }
  

---

• 您的代码总共是：

（不使用数组结构）

#include <stdio.h>
#include <stdlib.h> //don't forget to include this

struct student
{
    int studID;
    int *marks;
};

int main(void) 
{

    struct student s[100];
    int i, j, val, flag=0;

    printf(" \n Please enter the students ID# followed by their grades. When done entering\n");
    printf(" grades, enter 101 to start a new student or 102 to exit entry.\n\n\n ");

    for(i=0;i<10;) 
    {

        printf("Enter student ID#: ");
        scanf("%d",&s[i].studID);

        s[i].marks = malloc(100*sizeof(int)); //allocating memory

        printf("\nFor student ID# %d\n",s[i].studID);

        for(j=0;j<100;j++) 
        {
            printf("Enter grades: ");
            scanf("%d",&val);

            if(val>=0 && val<=100) 
            {
                s[i].marks[j]=val;
            }
            else if(val==101) 
            {
                s[i].marks[j]=-1;
                s[i].marks = realloc(s[i].marks,(j+1)*sizeof(int)); //resize
                break;
            }
            else if(val==102) 
            {
                s[i].marks[j]=-1;
                s[i].marks = realloc(s[i].marks,(j+1)*sizeof(int)); //resize
                flag=1;
                break;
            }
            else 
            {
                printf("\ninvalid entry\n");
                j--;
            }
        }

        printf("\n\n----------\n\n");

        i++;

        if(flag==1)
            break;
    }

    int num=i;

    for(i=0; i<num ; i++) 
    {
        printf("\nInformation for student ID number %d:\n",s[i].studID);
        for(j=0; s[i].marks[j]!=-1; j++)
        printf("Grades: %d\n",s[i].marks[j]);
    }


    //freeing memory    
    for(i=0; i<num ; i++)
    {
        free(s[i].marks);
    }

 }

Answer 2

//maybe add this second array?

我不这么认为。你说你想要一个结构数组。这就是s。结构也包含一个数组这一事实对我来说似乎不是问题，除非它被某些奇怪的规则明确禁止。

我不确定在那之后该去哪里。如果我删除数组 从结构中的标记，任何地方s[i].marks[j] 我得到错误 “下标值既不是数组也不是指针也不是向量”。

你当然知道。如果删除数组维度，则marks 是int，而不是数组。只有 s 是一个数组。只有数组或指针可以是[indexed]。

但是看看你原来的例子。你有 10 个学生，每个学生有 100 分。通过将数组保留在您的 struct 定义中，代码应该可以正常工作。你说'获取学生i 然后他们的标记j'。这应该可以正常工作。不是吗？你得到什么错误？

Answer 3

从评论开始，您的包含数组的结构数组一开始是正确的。如前所述，唯一缺少的部分是添加一个成员来获取/存储每个 studentID 的分数（成绩）。添加这将允许逻辑工作并简化处理程序输出。实际上，它会简化为类似于以下的逻辑（包括按 ID 对结果进行排序）：

...
/* constants for max students and marks */
enum { NSTD = 64, NMARK = 100 };

typedef struct {
    int sid;            /* student ID    */
    int nmarks;         /* number grades */
    int marks[NMARK];   /* grades array  */
} student;

int main (int argc, char **argv) {

    int i, j, sidx = 0;
    student s[NSTD] = {{ .sid = 0 }};
    ...
    for (; sidx < NSTD;) {  /* for each id up to max NSTD */
        int grade = 0;

        printf (" enter student ID: ");     /* enter/validate ID */
        while (scanf (" %d", &s[sidx].sid) != 1) { ... }

        printf ("  Enter grades for student %d: ", s[sidx].sid);
        while (scanf (" %d", &grade) == 1) {    /* for each grade */
            ...
            s[sidx].marks[s[sidx].nmarks++] = grade;
        }
        sidx++;     /* increment student index */
    }
    ...

输入所有数据并知道每个 studentID 有多少成绩后，对数据的迭代就变成了对每个 studentID 和标记的简单嵌套循环，例如：

for (i = 0; i < sidx; i++) {
    printf ("\n Student ID : %3d     grades :", s[i].sid);
    for (j = 0; j < s[i].nmarks; j++)
        printf ("  %2d", s[i].marks[j]);
}

要对数据进行排序（或者当您认为排序 C 中的任何内容时）使用qsort。 qsort 的唯一挑战是编写一个小函数来告诉 qsort 如何对您传递的任何内容进行排序。 （您将传递一个指向student 的指针，因此只需根据student->sid 进行排序）。由于比较函数的输入将是 const void *（一个常量 void 指针），因此您只需将其转换为 student * 并引用 ID 成员：

int cmpsid (const void *a, const void *b)
{
    student *s1 = (student *)a;  /* technically you should add 'const' */
    student *s2 = (student *)b;  /* omitted for simmplicity */

    /* comparing (a > b) - (a < b) prevents potential overflow */
    return (s1->sid > s2->sid) - (s1->sid < s2->sid);
}

您可以通过在比较中简单地应用转换来避免中间变量 s1 和 s2：

int cmpsid (const void *a, const void *b)
{
    /* (a > b) - (a < b) prevents potential overflow */
    return (((student *)a)->sid > ((student *)b)->sid) - 
            (((student *)a)->sid < ((student *)b)->sid);
}

（以你更清楚的为准）

您调用qsort 对结构s 的数组进行排序很简单：

qsort (s, sidx, sizeof *s, cmpsid); /* sort by student ID */

将其放在一起并添加有意义的其他验证，您可以执行以下操作。从文本文件中读取数据的代码（如果没有给出文件名，则默认提示输入）：

#include <stdio.h>
#include <stdlib.h>     /* for qsort */

/* constants for max students and marks */
enum { NSTD = 64, NMARK = 100 };

typedef struct {
    int sid;            /* student ID    */
    int nmarks;         /* number grades */
    int marks[NMARK];   /* grades array  */
} student;

int cmpsid (const void *a, const void *b);  /* qsort comparison */

int main (int argc, char **argv) {

    int i, j, sidx = 0;
    student s[NSTD] = {{ .sid = 0 }};
    FILE *fp = argc > 1 ? fopen (argv[1], "r") : stdin;

    if (!fp) {  /* validate file open for reading */
        fprintf (stderr, "error: file open failed '%s'.\n", argv[1]);
        return 1;
    }

    printf ("\n enter student ID followed by grade (0-100)\n"
            " 101 for next student, 102 when finished.\n\n");

    for (; sidx < NSTD;) {  /* for each id up to max NSTD */

        int grade = 0, tries = 0;

        printf (" enter student ID: ");     /* enter/validate ID */
        while (scanf (" %d", &s[sidx].sid) != 1) {
            fprintf (stderr, " error: invalid student ID.\n");
            if (++tries == 3) {
                fprintf (stderr, " (max attempts reached, exiting.)\n");
                goto done;
            }
            printf (" enter student ID: ");
        }

        printf ("  Enter grades for student %d: ", s[sidx].sid);
        while (scanf (" %d", &grade) == 1) {    /* for each grade */
            if (grade < 0 || 102 < grade) {     /* invalid entry */
                fprintf (stderr, " warning: invalid entry '%d'.\n", grade);
                continue;
            }
            if (grade == 101) break;            /* next student */
            if (grade == 102) {                 /* exit input   */
                if (s[sidx].nmarks) sidx++;
                goto done;
            }

            s[sidx].marks[s[sidx].nmarks++] = grade;
            if (s[sidx].nmarks == NMARK) {
                fprintf (stderr, "  warning: max grades for ID %d.\n",
                        s[sidx].sid);
                break;
            }
        }
        sidx++;     /* increment student index */
    }
    done:;

    if (fp != stdin) fclose (fp);       /* close file if not stdin */

    qsort (s, sidx, sizeof *s, cmpsid); /* sort by student ID */

    for (i = 0; i < sidx; i++) {        /* output sorted data */
        printf ("\n Student ID : %3d     grades :", s[i].sid);
        for (j = 0; j < s[i].nmarks; j++)
            printf ("  %2d", s[i].marks[j]);
    }
    putchar ('\n');

    return 0;
}

/* integer comparison (use for all numeric types) */
int cmpsid (const void *a, const void *b)
{
    /* (a > b) - (a < b) prevents potential overflow */
    return (((student *)a)->sid > ((student *)b)->sid) - 
            (((student *)a)->sid < ((student *)b)->sid);
}

int cmpsid2 (const void *a, const void *b);
int cmpsid2 (const void *a, const void *b)
{
    student *s1 = (student *)a;  /* technically you should add 'const' */
    student *s2 = (student *)b;  /* omitted for simmplicity */

    /* comparing (a > b) - (a < b) prevents potential overflow */
    return (s1->sid > s2->sid) - (s1->sid < s2->sid);
}

示例输入

输入 10 名学生，每人 10 分：

$ cat dat/idmarks.txt
667 82 79 78 78 97 84 85 77 95 86 101
166 97 97 88 97 74 81 98 82 93 76 101
497 77 95 80 98 71 80 91 77 75 98 101
 31 82 78 79 95 92 86 87 95 91 83 101
515 76 76 93 87 71 72 77 92 72 93 101
145 81 79 95 91 99 93 95 99 83 77 101
517 92 98 96 75 83 89 95 93 75 95 101
836 97 84 98 98 91 98 88 71 90 75 101
381 82 98 76 81 90 72 93 93 76 86 101
 11 92 86 96 88 78 91 92 76 87 82 102

使用/输出示例

$ ./bin/studentmarks <dat/idmarks.txt

 enter student ID followed by grade (0-100)
 101 for next student, 102 when finished.

 <snip prompts>

 Student ID :  11     grades :  92  86  96  88  78  91  92  76  87  82
 Student ID :  31     grades :  82  78  79  95  92  86  87  95  91  83
 Student ID : 145     grades :  81  79  95  91  99  93  95  99  83  77
 Student ID : 166     grades :  97  97  88  97  74  81  98  82  93  76
 Student ID : 381     grades :  82  98  76  81  90  72  93  93  76  86
 Student ID : 497     grades :  77  95  80  98  71  80  91  77  75  98
 Student ID : 515     grades :  76  76  93  87  71  72  77  92  72  93
 Student ID : 517     grades :  92  98  96  75  83  89  95  93  75  95
 Student ID : 667     grades :  82  79  78  78  97  84  85  77  95  86
 Student ID : 836     grades :  97  84  98  98  91  98  88  71  90  75

查看代码以及其他答案，如果您有任何问题，请告诉我。选择你的结构内容，让它适合你，它应该让生活更轻松。