Are “malloc(sizeof(struct a *))” and “malloc(sizeof(struct a))” the same?

by

There seems to be a fundamental misunderstanding.

malloc(sizeof(struct a) * n) allocates n number of type struct a elements.

No, that’s just what one usually does use it as after such a call. malloc(size) allocates a memory region of size bytes. What you do with that region is entirely up to you. The only thing that matters is that you don’t overstep the limits of the allocated memory. Assuming 4 byte float and int and 8 byte double, after a successful malloc(100*sizeof(float));, you can use the first 120 of the 400 bytes as an array of 15 doubles, the next 120 as an array of 30 floats, then place an array of 20 chars right behind that and fill up the remaining 140 bytes with 35 ints if you wish. That’s perfectly harmless defined behaviour.

malloc returns a void*, which can be implicitly cast to a pointer of any type, so

some_type **array = malloc(100 * sizeof(data *)); // intentionally unrelated types

is perfectly fine, it might just not be the amount of memory you wanted. In this case it very likely is, because pointers tend to have the same size regardless of what they’re pointing to.

More likely to give you the wrong amount of memory is

data *array = malloc(n * sizeof(data*));

as you had it. If you use the allocated piece of memory as an array of n elements of type data, there are three possibilities

  1. sizeof(data) < sizeof(data*). Then your only problem is that you’re wasting some space.
  2. sizeof(data) == sizeof(data*). Everything’s fine, no space wasted, as if you had no typo at all.
  3. sizeof(data) > sizeof(data*). Then you’ll access memory you shouldn’t have accessed when touching later array elements, which is undefined behaviour. Depending on various things, that could consistently work as if your code was correct, immediately crash with a segfault or anything in between (technically it could behave in a manner that cannot meaningfully be placed between those two, but that would be unusual).

If you intentionally do that, knowing point 1. or 2. applies, it’s bad practice, but not an error. If you do it unintentionally, it is an error regardless of which point applies, harmless but hard to find while 1. or 2. applies, harmful but normally easier to detect in case of 3.

In your examples. data was 4 resp. 8 bytes (probably), which on a 64-bit system puts them into 1. resp. 2. with high probability, on a 32-bit system into 2 resp. 3.

The recommended way to avoid such errors is to

type *pointer = malloc(num_elems * sizeof(*pointer));

More Related Contents:

  1. C pointer to another struct
  2. Pointer to pointer of structs indexing out of bounds(?) when I try to index anything other than zero
  3. C: pointer to struct in the struct definition
  4. Passing a 2D array of structs
  5. C typedef of pointer to structure
  6. Rationale behind the container_of macro in linux/list.h
  7. How is the result struct of localtime allocated in C?
  8. How to include a dynamic array INSIDE a struct in C?
  9. Array of size 0 at the end of struct [duplicate]
  10. How to initialize a pointer to a struct in C?
  11. Returning a struct pointer
  12. How can I correctly assign a new string value?
  13. Create a pointer to two-dimensional array
  14. What is an opaque pointer in C?
  15. What is the reason for using a double pointer when adding a node in a linked list?
  16. Post-increment on a dereferenced pointer?
  17. What exactly is a C pointer if not a memory address?
  18. Reversing a string in C
  19. Why do I need to use type** to point to type*?
  20. What does malloc(0) return? [duplicate]
  21. Passing struct to function
  22. Why can’t we initialize members inside a structure?
  23. Using intptr_t instead of void*?
  24. Are C-structs with the same members types guaranteed to have the same layout in memory?
  25. Does C99 guarantee that arrays are contiguous?
  26. Order of operations for dereference and bracket-ref in C
  27. Doesn’t a 2D array decay to pointer to pointer
  28. lvalue required as increment operand
  29. Iterating over same type struct members in C
  30. How can I malloc a struct array inside a function? Code works otherwise

Leave a Comment