How can you allocate memory dynamically for an array of structs using malloc?

Question

I want to implement a simple database in C, and I need to use an array of structs and realloc it when resizing is needed.
After continuous efforts, I realized that I cannot use malloc for an array of structs because malloc returns a pointer, so I cannot have a struct on the left side of the equal symbol. So my question is:

How can you malloc an array of structs?

Answer 1

Given a pointer p to the first structure of an array of structures, you can access the structure with index i using p[i].

You can allocate and initialize an array of structures like this:

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


typedef struct { int MyInteger; } MyStructure;


MyStructure *GiveMeAnArrayOfStructures(size_t NumberOfStructures)
{
    //  Allocate memory.
    MyStructure *p = malloc(NumberOfStructures * sizeof *p);
    if (!p)
    {
        fprintf(stderr, "Error, unable to allocate memory.\n");
        exit(EXIT_FAILURE);
    }

    //  Initialize structures.
    for (size_t i = 0; i < NumberOfStructures; ++i)
        p[i].MyInteger = i;

    //  Return array, via pointer to first element.
    return p;
}

This example uses a structure member on the left side of an assignment, but we can also use a structure on the left side:

    for (size_t i = 0; i < NumberOfStructures; ++i)
    {
        MyStructure Example = { i };
        p[i] = Example;
    }

Answer 2

Assume a struct type named struct s, and you want to allocate space for N instances:

struct s *arr = malloc( sizeof *arr * N );

Graphically:

      struct s *    struct s
      +---+         +---+
 arr: |   | ------> |   | arr[0]
      +---+         +---+
                    |   | arr[1]
                    +---+
                     ...
                    +---+
                    |   | arr[N-1]
                    +---+

In other words, malloc reserves enough space to store N structs, and returns a pointer to the beginning of that space, which gets stored in arr. You can use the subscript operator [] on pointers as well as array expressions, so you'd refer to each struct as arr[i] and access members as arr[i].member.

the majority of the questions avoid the use of type-casting before the "malloc" keyword. What is the benefit of it ? I was told to always use type casting before malloc.

In the earliest versions of C (known as K&R C) the void type did not exist, and there was no way to declare a "generic" pointer like void *. In those days, malloc (and calloc and realloc) returned a char *, so if you wanted to assign a result to something that wasn't a char *, you had to cast the result:

/** K&R C */
int *ptr = (int *) malloc( sizeof *ptr * N );

That changed in the 1989 standard, which introduced the void type and created the rule that void * could be directly assigned to other pointer types, making the cast redundant. So from C89 onward, you can write:

/** C89 and later */
int *ptr = malloc( sizeof *ptr * N );

The cast is no longer necessary, and most of us recommend leaving it off because it only adds clutter and the potential for making mistakes (and under the C89 standard could suppress a useful diagnostic if you forgot to #include <stdlib.h>). The only times you must cast the result of malloc are:

• You are using an ancient K&R compiler;
• You are compiling the code as C++;

Unlike C, C++ does not allow direct assignment between void * and other pointer types, and requires you to use a cast. But if you're writing C++, you shouldn't be using malloc anyway.