Is it valid to call malloc with a pointer of the type of the first member?

Question

I am building a hash library, this library works with different structs and all those structs haves an unsigned type as first member, an example:

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

struct data {
    unsigned hash;
    void (*func)(struct data *);
};

struct another_data {unsigned hash; int value;};

static void *hash_insert(const char *text, size_t size)
{
    unsigned *hash;

    hash = malloc(size);
    // *hash = hash(text);
    *hash = (unsigned)strlen(text);
    return hash;
}

static void func(struct data *data)
{
    printf("%u\n", data->hash);
}

int main(void)
{
    struct data *data;

    data = hash_insert("Some text", sizeof *data);
    data->func = func;
    data->func(data);
    free(data);
    return 0;
}

Since the first member of the struct and the struct itself haves the same alignment requirements, is it valid to call malloc with a pointer of the type of the first member in order to reserve space for the entire struct?

unsigned *hash = malloc(size); /* where size is the size of the struct */

EDIT:

In this related question provided by @MohitJain:

struct Msg
{
   unsigned int a;
   unsigned int b;
};

...

uint32_t* buff = malloc(sizeof(Msg));

// Alias that buffer through message
Msg* msg = (Msg*)(buff);

The strict aliasing rule makes this setup illegal

But in my case I am returning a void * from the function, I can use this (returned) pointer inside main without alignment issues, is this assumption correct?

Answer 1

malloc is guaranteed to return memory aligned for any type.

Therefore it will work regardless of the alignment requirement of the different subtypes.

Answer 2

The rules about effective type and pointer aliasing say that it is fine to convert pointers between a struct (or any other "aggregate") and a pointer of the same type as the first appearing member in the struct. And another rule says that structs are not allowed to have padding in the very beginning.

So it is fine as far as the C standard goes... which doesn't really say much of the quality of the program.

The code does not make much sense. You clearly want to use the whole struct, so why not return a pointer of the struct type? Don't complicate things for the sake of it. You should always avoid using void* when there is no need for it, to increase type safety.

Overall, all these things would sort themselves out in a multi-file project with proper program design. If you had a separate file with the hash type and all functions using that type, there would be no doubt of how to write the program.

Answer 3

Since structure member are allocated in the order they are declared, using

unsigned *hash = malloc(size); /* where size is the size of the struct */

can work if your pourpose is just using the hash data. It fails if you want to apply pointer aritmetic on it, so in this case using

hash++

is an undefined behavior.

Answer 4

Yes it is perfectly fine for first member type to point to the memory returned by malloc (Memory is aligned for any data type). What you do with this memory later may cause issues if you are not careful.

[Extracts from Joachim Pileborg's answer @ Maintaining an array of pointers in C that points to two related types with minor changes]

Having a structure inside other structures or a common data type in other structures is a common way of emulating inheritance in C. This common member should contain the minimal set of data common to all structures in the "inheritance" hierarchy, and it must always be the first member in the inheriting structures.

---

Possible issue with this scheme is:

This "inheritance" scheme will work on all modern PC-like systems and their compilers, and have done so for a long time, but there's no guarantee that it will work on all systems and all compilers (if you're planning on porting the code to some rare system with weird hardware and compiler you might want to look out, but the cases where the "inheritance" scheme will not work is very small, and most people will never come in contact with such a system in their entire lifetime.) But once you point the same memory with struct data *, you may fall victime of strict aliasing rule. So you need to be careful there. Further readL What is the strict aliasing rule?

Answer 5

unsigned *hash = malloc(size);

This will create allocate an array of unsigned integers. Total number of integers allocated will be size/sizeof(int). hash here is pointer to int.

Since the first member of the struct and the struct itself haves the same alignment requirements, is it valid to call malloc with a pointer of the type of the first member in order to reserve space for the entire struct?

The point is, that hash here is a separate variable which has nothing to do with the hash inside the structure. (It is in a separate namespace, if you want to look it up)

You can then cast hash to the struct variable.

struct data *data;
unsigned *hash = malloc(size * sizeof(struct));
data = (struct data *) hash;

But, what is the point. You can just as well remove the unnecessary unsigned hash pointer and go with the traditional.

struct data *data;
data = malloc(size * sizeof(struct));