Problem with passing between pointers of arrays in structures

Question

I have been sitting on this problem for 3 hours and I would appreciate it if you could guide me, We have the student structure that contains a name, and points to an array of pointers of size 3 only and it should point to 3 different teachers (random of course), when I try to return the pointer to the random array from teacherArray, within the operation AttemptTeacherToStudents, in practice, nothing is received, And the pointer remains empty. I would really appreciate the help

My structs:

typedef struct
{
    char name[20];
    struct ClassRoom * myClass;
}Teacher;

typedef struct {
    char * name;
    struct ClassRoom *myClassRoom;
    struct Teacher *myTeachers[3];
    
}Student;

int InitalizeStudent2(Student *student, char *name, Teacher *teacher)
{
    student->name= name;
    *student->myTeachers = teacher;
    printf("%s", name);

    return 0;
}

The problem is with this code:

Teacher ** teacherArray(Teacher * teachers)
{
    Teacher *randomArray[3];
    int i = 0;
    while (i<3)
    {
        Teacher * teacher=teachers + (rnd() % 6);
        randomArray[i++] = teacher;

    }
    return randomArray;
}
void AttempTeacherToStudents(Teacher* teachers)
{
    Student * allOfMYStudents = (Student *)malloc(5 * sizeof(Student));
    for (int i = 0; i < 5; i++)
    {
        char name[255];
        sprintf(name, "Student_%d", 100 + i);
        char *newName = _strdup(name);
        InitalizeStudent2(&allOfMYStudents[i], newName, *teacherArray(teachers));
    }

}


Teacher** InitalizeGenrealTeacher()
{
    char allTeachers[6][6] = { "Teach1\0", "Tech2\0", "Tech3\0","Tech4\0", "Tech4\0", "Tech5\0" };
    Teacher * myTeachers =(Teacher*) calloc(6 , sizeof( Teacher));

    for (int i = 0; i < 6; i++)
    {
        InitalizeTeacher(&myTeachers[i], allTeachers[i]);
        

    }
    return myTeachers;
    
}


int main()
{
    srand(time(NULL));
    Teacher*pMyTeacher = InitalizeGenrealTeacher();
    for (int i = 0; i < 6; i++)
    {

        printf("%s \n", pMyTeacher[i].name);
    }
    

    AttempTeacherToStudents(pMyTeacher);
}

the problem is, why the pointer of "myTeachers" is empty at [1][2]? why does cell number [0] not null too?

Answer 1

First, turn on compiler warnings. They will give you a lot of extra information and avoid a lot of frustration. How you do that depends on the compiler/IDE you're using.

---

int InitalizeStudent2(Student *student, char *name, Teacher *teacher)
{
    // student->name is uninitialized
    strcpy(student->name, name);

    // student->myTeachers is an existing array of 3 elements, yet you're assigning an existing array to it.
    // student->myTeachers is `struct Teacher*` which does not exist, it should be `Teacher*`
    *student->myTeachers = teacher;

    return 0;
}

student->name is defined as char *name. Unlike char name[20], you need to allocate memory for the student's name. I would recommend using strdup for that, and to make Teacher and Student consistent as to how they store strings.

student->myTeachers is declared as struct Teacher *myTeachers[3]. There is no struct Teacher only Teacher. typedef struct { ... } Teacher only declares Teacher.

student->myTeachers is allocates an array of 3 elements, yet you already have an allocated array of Teachers. If you're going to add an existing array to Student, declare it as Teacher *myTeachers to just store the pointer and assign it with student->myTeachers = teacher.

Note that the teacher passed to InitalizeStudent2 is from teacherArray and has already been deallocated. Read on.

---

Teacher ** teacherArray(Teacher * teachers)
{
    // This will be deallocated when the program returns.
    Teacher *randomArray[3];
    int i = 0;
    while (i<3)
    {
        // I'm not sure what the rand() % 6 is for.
        Teacher *teacher = teachers + (rand() % 6);
        randomArray[i++] = teacher;

    }
    return randomArray;
}

Teacher *randomArray[3] allocates automatic memory. This memory will be deallocated once teacherArray returns; that means something can overwrite that memory. It's very convenient, but it means if you return it something might overwrite it. Instead, you need to allocate the memory with malloc or calloc and then free it later. Alternatively, the caller can allocate the array and pass it into teacherArray.

Otherwise, it's unclear what this function is trying to do.

---

Teacher** InitalizeGenrealTeacher()
{
    // It's not necessary to add the \0 to strings.
    // But do remember to allocate an extra byte for the \0.
    char allTeachers[6][6] = { "Teach1\0", "Tech2\0", "Tech3\0","Tech4\0", "Tech4\0", "Tech5\0" };

    // There's no need to cast calloc or malloc.
    Teacher * myTeachers = (Teacher*) calloc(6 , sizeof( Teacher));

    for (int i = 0; i < 6; i++)
    {
        InitalizeTeacher(&myTeachers[i], allTeachers[i]);
    }

    // The function returns `Teacher **` but myTeachers is `Teacher *`.
    return myTeachers;
}

While C strings are terminanted by a null byte, "" adds the null byte for you; it's just "Teach1". You do need to remember the null byte when allocating memory, so "Teach1" needs 6 bytes. Since these are fixed size strings, you can let the compiler figure it out with char allTeachers[6][].

The function returns Teacher **, which would be an array of Teacher pointers. But myTeachers is a Teacher *, which is an array of Teacher structs.

InitalizeTeacher is missing from your code.