C 中具有动态内存分配的指针向量
Vector of pointers with dynamic memory allocation in C
作为作业的一部分，我正在学习 C 中的指针向量。但是，我的代码的一部分没有 运行，我不明白为什么。
尽管我的问题具体出在 selectApproved 函数中，但我已经包含了下面的完整代码。
我只是在函数 selectApproved 中遇到问题。它接收类型为 Student 的指针向量，这是我定义的结构，其元素中包含两个不同测试的成绩。该函数应该递归地识别取得及格结果的学生（定义为 test1 + test2 >= 10）和 return 一个指针向量，其中指针向量的每个元素包含一个指向 a 的指针学生结构。
在语句printf("Position %d\n", position); 之后，在所有递归调用发生之后，立即发生错误。具体来说，我知道错误发生在这个语句中：approved_students[position] = vector[position];。
我不明白为什么会出现这个错误。发生所有递归调用后，我动态分配我的指针向量以准确保存通过的学生人数： approved_students = (Student **) malloc( (*passed) * sizeof(Student * ))。据我了解，approved_student 应该具有 *passed 的 "slots" 的确切数量（在本例中为 4 个插槽）。
我什至对待在 if 语句 if(num_students == 0) 中没有学生被批准的事件。
我知道我的递归函数运行良好，因为 printf("Position %d\n", position); 打印出一个 3，这意味着有 4 个学生被批准正如预期的那样（学生 0、1、2、3 已被批准）。我使用的 IDE (Visual Studio 2012) 允许我做 approved_students[position] = vector[position];。
在我看来，这句话是说，例如 approved_students[position] 将包含指向位于 vector[position][ 中的结构的指针=35=]。毕竟，approved_student 是一个指针向量。
我真的不知道为什么这个功能不起作用。有人可以帮忙吗？
我觉得
# include <stdio.h>
# include <stdlib.h>
# include <string.h>
struct Studentgrade{
float test1;
float test2;
};
typedef struct Studentgrade Grade;
struct student
{
int ID_number;
char name[51];
Grade *scores;
};
typedef struct student Student;
Student *createStudent(int ID_num, char name_student[], float test1_grade, float test2_grade){
int i = 0;
Student *newStudent = (Student *) malloc(sizeof(Student));
if (newStudent == NULL){
printf("Error in memory allocation\n");
exit(1);
}
newStudent->scores = (Grade *) malloc(sizeof(Grade));
if (newStudent->scores == NULL){
printf("Error in memory allocation\n");
exit(1);
}
newStudent->scores->test1 = test1_grade;
newStudent->scores->test2 = test2_grade;
newStudent->ID_number = ID_num;
while(i < 51 && name_student[i] != '[=10=]')
newStudent->name[i] = name_student[i++];
newStudent->name[i] = '[=10=]';
return newStudent;
}
Student **selectApproved(Student *vector[], int num_students, int *passed){
int position;
int i;
float comparison;
Student **approved_students = NULL;
if(num_students == 0){
if(*passed == 0){
printf("No student passed\n");
return NULL;
}
else{
approved_students = (Student **) malloc( (*passed) * sizeof(Student *));
/*for (i = 0; i < (*passed); i++)
approved_students[i] = (Student *) malloc(sizeof(Student *));*/
if (approved_students == NULL){
printf("Error in memory allocation\n");
exit(1);
}
return approved_students;
}
}
comparison = (vector[0]->scores->test1) + (vector[0]->scores->test2);
if(comparison >= 10){
position = *passed;
(*passed)++;
approved_students = selectApproved(&vector[1], num_students - 1, passed);
printf("Position %d\n", position);
approved_students[position] = vector[position];
}
else
selectApproved(&vector[1], num_students - 1, passed);
return approved_students;
}
int main(void){
Student *vpstudent[12];
Student **vpstudent2;
int i = 0;
vpstudent[0] = createStudent(444,"Rita",6.4, 7.8);
vpstudent[1] = createStudent(111,"Rita",5.6, 8.8);
vpstudent[2] = createStudent(999,"Rita",8.2, 7.1);
vpstudent[3] = createStudent(555,"Dina",2.7, 6.4);
vpstudent[4] = createStudent(777,"Lana",9.5, 5.3);
vpstudent[5] = createStudent(666,"Tais",2.2, 2.8);
vpstudent[6] = createStudent(222,"Cris",3.1, 4.2);
vpstudent[7] = createStudent(333,"Vera",4.4, 5.4);
vpstudent[8] = createStudent(888,"Cris",4.4, 5.4);
vpstudent[9] = createStudent(303,"Vera",4.4, 5.4);
vpstudent[10] = createStudent(101,"Cris",5.4, 3.4);
vpstudent[11] = createStudent(202,"Vera",1.4, 8.4);
vpstudent2 = selectApproved(vpstudent, 12, &i);
return 0;
}
您似乎依赖最终递归到 selectApproved 来为您的向量分配内存。
但是，您不能保证分配的指针实际上会返回到调用堆栈中。
"if(comparison >= 10)" 的 Else 条件不加载 approved_students。
if(comparison >= 10){
...
approved_students = selectApproved(&vector[1], num_students - 1, passed);
...
} else {
approved_students = selectApproved(&vector[1], num_students - 1, passed);
}
return approved_students;
据此，我会说最深递归级别的学生没有通过。
作为作业的一部分，我正在学习 C 中的指针向量。但是，我的代码的一部分没有 运行，我不明白为什么。 尽管我的问题具体出在 selectApproved 函数中，但我已经包含了下面的完整代码。
我只是在函数 selectApproved 中遇到问题。它接收类型为 Student 的指针向量，这是我定义的结构，其元素中包含两个不同测试的成绩。该函数应该递归地识别取得及格结果的学生（定义为 test1 + test2 >= 10）和 return 一个指针向量，其中指针向量的每个元素包含一个指向 a 的指针学生结构。
在语句printf("Position %d\n", position); 之后，在所有递归调用发生之后，立即发生错误。具体来说，我知道错误发生在这个语句中：approved_students[position] = vector[position];。
我不明白为什么会出现这个错误。发生所有递归调用后，我动态分配我的指针向量以准确保存通过的学生人数： approved_students = (Student **) malloc( (*passed) * sizeof(Student * ))。据我了解，approved_student 应该具有 *passed 的 "slots" 的确切数量（在本例中为 4 个插槽）。 我什至对待在 if 语句 if(num_students == 0) 中没有学生被批准的事件。
我知道我的递归函数运行良好，因为 printf("Position %d\n", position); 打印出一个 3，这意味着有 4 个学生被批准正如预期的那样（学生 0、1、2、3 已被批准）。我使用的 IDE (Visual Studio 2012) 允许我做 approved_students[position] = vector[position];。 在我看来，这句话是说，例如 approved_students[position] 将包含指向位于 vector[position][ 中的结构的指针=35=]。毕竟，approved_student 是一个指针向量。
我真的不知道为什么这个功能不起作用。有人可以帮忙吗？ 我觉得
# include <stdio.h>
# include <stdlib.h>
# include <string.h>
struct Studentgrade{
float test1;
float test2;
};
typedef struct Studentgrade Grade;
struct student
{
int ID_number;
char name[51];
Grade *scores;
};
typedef struct student Student;
Student *createStudent(int ID_num, char name_student[], float test1_grade, float test2_grade){
int i = 0;
Student *newStudent = (Student *) malloc(sizeof(Student));
if (newStudent == NULL){
printf("Error in memory allocation\n");
exit(1);
}
newStudent->scores = (Grade *) malloc(sizeof(Grade));
if (newStudent->scores == NULL){
printf("Error in memory allocation\n");
exit(1);
}
newStudent->scores->test1 = test1_grade;
newStudent->scores->test2 = test2_grade;
newStudent->ID_number = ID_num;
while(i < 51 && name_student[i] != '[=10=]')
newStudent->name[i] = name_student[i++];
newStudent->name[i] = '[=10=]';
return newStudent;
}
Student **selectApproved(Student *vector[], int num_students, int *passed){
int position;
int i;
float comparison;
Student **approved_students = NULL;
if(num_students == 0){
if(*passed == 0){
printf("No student passed\n");
return NULL;
}
else{
approved_students = (Student **) malloc( (*passed) * sizeof(Student *));
/*for (i = 0; i < (*passed); i++)
approved_students[i] = (Student *) malloc(sizeof(Student *));*/
if (approved_students == NULL){
printf("Error in memory allocation\n");
exit(1);
}
return approved_students;
}
}
comparison = (vector[0]->scores->test1) + (vector[0]->scores->test2);
if(comparison >= 10){
position = *passed;
(*passed)++;
approved_students = selectApproved(&vector[1], num_students - 1, passed);
printf("Position %d\n", position);
approved_students[position] = vector[position];
}
else
selectApproved(&vector[1], num_students - 1, passed);
return approved_students;
}
int main(void){
Student *vpstudent[12];
Student **vpstudent2;
int i = 0;
vpstudent[0] = createStudent(444,"Rita",6.4, 7.8);
vpstudent[1] = createStudent(111,"Rita",5.6, 8.8);
vpstudent[2] = createStudent(999,"Rita",8.2, 7.1);
vpstudent[3] = createStudent(555,"Dina",2.7, 6.4);
vpstudent[4] = createStudent(777,"Lana",9.5, 5.3);
vpstudent[5] = createStudent(666,"Tais",2.2, 2.8);
vpstudent[6] = createStudent(222,"Cris",3.1, 4.2);
vpstudent[7] = createStudent(333,"Vera",4.4, 5.4);
vpstudent[8] = createStudent(888,"Cris",4.4, 5.4);
vpstudent[9] = createStudent(303,"Vera",4.4, 5.4);
vpstudent[10] = createStudent(101,"Cris",5.4, 3.4);
vpstudent[11] = createStudent(202,"Vera",1.4, 8.4);
vpstudent2 = selectApproved(vpstudent, 12, &i);
return 0;
}
您似乎依赖最终递归到 selectApproved 来为您的向量分配内存。
但是，您不能保证分配的指针实际上会返回到调用堆栈中。
"if(comparison >= 10)" 的 Else 条件不加载 approved_students。
if(comparison >= 10){
...
approved_students = selectApproved(&vector[1], num_students - 1, passed);
...
} else {
approved_students = selectApproved(&vector[1], num_students - 1, passed);
}
return approved_students;
据此，我会说最深递归级别的学生没有通过。