I want to add the reference of a struct to an struct array. But i can only deference the struct and set a copy of the struct to the index. Is there a way to give the indexes of students the address of the Student structs passed in the add_student function?

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

typedef struct student {
    int age;
    char *name;
} Student;

Student *students;

int size = 0;

void add_student(Student *student) {
    Student *temp;
    size++;
    temp = realloc(students, sizeof(Student)*size);
    if(!temp) {
        printf("Cannot realloc memory\n");
        exit(1);
    }
    temp[size-1] = *student;
    students = temp;
}

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

    students = malloc(0);
    Student student;
    student.name = "name1";
    student.age = 11;
    add_student(&student);
    Student student2;
    student2.name = "name2";
    student2.age = 13;
    add_student(&student2);

    student2.age = 22;
    student2.name = "name33";
// I change the student2 and i would except that the Student struct gets changed in students[1]

    return 0;
}

>Solution :

A struct array contains struct elements, not references to struct elements. You need to have an array of pointers instead, like

Student **students;

and continue in this manner when you realloc, so temp will have the same type. And then you can do this:

temp[size-1] = student;

because then temp will be an array of Student pointers and therefore you will be able to store references as its elements.

For more information, read https://www.geeksforgeeks.org/how-to-declare-and-initialize-an-array-of-pointers-to-a-structure-in-c/

which specifies this as the general form for such dynamic structure pointer arrays:

< structure_name >  ** < array_name > = <structure_name **> malloc ( sizeof( <structure_name> )* size ) ;

The same page provides this sample code for illustration:

// C Program to implement
// Dynamic Array of structure
// pointer
#include <stdio.h>
#include <stdlib.h>
 
typedef struct node {
    int number;
    char character;
} node;
 
int main(void)
{
    // First pointer to structure
    node* structure_ptr1 = (node*)malloc(sizeof(node));
    // Second pointer to structure
    node* structure_ptr2 = (node*)malloc(sizeof(node));
    // Third pointer to structure
    node* structure_ptr3 = (node*)malloc(sizeof(node));
    // Fourth pointer to structure
    node* structure_ptr4 = (node*)malloc(sizeof(node));
 
    // Initializing structure pointers
 
    structure_ptr1->number = 100;
    structure_ptr1->character = 'a';
 
    structure_ptr2->number = 200;
    structure_ptr2->character = 'b';
 
    structure_ptr3->number = 300;
    structure_ptr3->character = 'c';
 
    structure_ptr4->number = 400;
    structure_ptr4->character = 'd';
 
    // Declaring the array dynamically for structure
    // pointers
 
    // Note that double pointer is
    // used for pointer to pointer
    node** structure_array
        = (node**)malloc(sizeof(node) * 4);
 
    // Initializing the array of structure pointers
 
    structure_array[0] = structure_ptr1;
    structure_array[1] = structure_ptr2;
    structure_array[2] = structure_ptr3;
    structure_array[3] = structure_ptr4;
 
    // Accessing dynamic 1D arrays - just like static 1D
    // arrays
    printf("Data:\n");
    for (int i = 0; i < 4; i++) {
        printf("%c - ", structure_array[i]->character);
        printf("%d\t\t", structure_array[i]->number);
        printf("\n");
    }
}