Inicializar matriz de estructuras en C

Tengo un problema al inicializar una matriz de estructuras. No estoy seguro de si lo estoy haciendo bien porque obtengo “inicialización de un tipo de puntero incompatible” y “asignación de un tipo de puntero incompatible”. Agregué en el código donde recibo estas advertencias, y cuando intento imprimir los datos de la estructura, solo obtengo basura como @@###

typedef struct
{
    char* firstName;
    char* lastName;
    int day;
    int month;
    int year;
} student;

// Initialize array

student** students = malloc(sizeof(student));
int x;
for(x = 0; x < numStudents; x++)
{
    // Here I get: "assignment from incompatible pointer type"
    students[x] = (struct student*)malloc(sizeof(student));
}

int arrayIndex = 0;

// Add struct

// Create student struct

// Here I get: "initialization from incompatible pointer type"
student* newStudent = {"john", "smith", 1, 12, 1983};

// Add it to the array
students[arrayIndex] = newStudent;
arrayIndex++;

Esto es incorrecto:

student** students = malloc(sizeof(student));

no quieres un **. Quieres un * y espacio suficiente para la cantidad de estudiantes que necesite

student *students = malloc(numStudents * sizeof *students); // or sizeof (student)
for (x = 0; x < numStudents; x++)
{
    students[x].firstName = "John"; /* or malloc and strcpy */
    students[x].lastName = "Smith"; /* or malloc and strcpy */
    students[x].day = 1;
    students[x].month = 12;
    students[x].year = 1983;
}

Si aún desea usar el código en su sección “//agregar estructura”, deberá cambiar la línea:

student* newStudent = {"john", "smith", 1, 12, 1983};

a

student newStudent = {"john", "smith", 1, 12, 1983};

Obtuvo “inicialización de un tipo de puntero incompatible” porque estaba intentando inicializar un puntero a student con un objeto de tipo student.

No relacionado con las advertencias del compilador, pero su malloc inicial es incorrecto; quieres:

malloc(sizeof(student *)* numStudents)

Para asignar espacio para un total de punteros ‘numStudents’ a un estudiante. La línea:

students[x] = (struct student*)malloc(sizeof(student));

Debiera ser:

students[x] = (student*)malloc(sizeof(student));

No existe tal cosa como ‘estudiante de estructura’. Ha declarado una estructura sin nombre y la ha definido como ‘estudiante’. Compara y contrasta con:

struct student
{
    char* firstName;
    char* lastName;
    int day;
    int month;
    int year;

};

Lo que crearía un tipo de ‘estudiante de estructura’ pero requiere que usted (en C) se refiera explícitamente a estudiante de estructura en lugar de simplemente a estudiante en otro lugar. Esta regla se cambia para C++, por lo que su compilador puede estar un poco confuso al respecto.

Como para:

student* newStudent = {"john", "smith", 1, 12, 1983};

Eso debería ser:

student newStudent = {"john", "smith", 1, 12, 1983};

Como la sintaxis de llaves es un literal directo, no es algo que deba señalar en otro lugar.

EDITAR: reflexionando, creo que aaa puede haber tomado más de una descripción general de esto que yo. ¿Es posible que, sin darse cuenta, esté utilizando un nivel adicional de desreferencia de puntero en todas partes? Así que querrías:

student* students = malloc(sizeof(student) * numStudents);

/* no need for this stuff: */
/*int x;
for(x = 0; x < numStudents; x++)
{
    //here I get: "assignment from incompatible pointer type" 
    students[x] = (struct student*)malloc(sizeof(student));
}*/

int arrayIndex = 0;

Y:

student newStudent = {"john", "smith", 1, 12, 1983};

//add it to the array
students[arrayIndex] = newStudent;
arrayIndex++;

Sujete la matriz que no se usa fuera del alcance de newStudent. De lo contrario, copiar los punteros a las cadenas es incorrecto.

student* students = malloc(sizeof(student)*numStudents);
int x;
for(x = 0; x < numStudents; x++)
{
    student newStudent = {"john", "smith", 1, 12, 1983}; // string copy are wrong still
    students[x] = newStudent;
}

Al inicializar, ¿no debería ser así?

student** students = (struct student**)malloc(sizeof(student*)*numStudents);

Sin embargo, ¿por qué apuntar a un puntero? Solo con un puntero a la estructura es suficiente, creo.