Behaviour of malloc(1) in C

Question

If I use char *char_commandout = (char *) malloc(1);, the allocated byte will store the " 0" at position 0 of the vector or will allocate a space for the value I want to store (at position 0) and one for the " 0" (at position 1)?

Answer 1

Victor already gave the basic answer to the question, I’ll add that it’s common for people to use a memset() to reset memory when necessary. When necessary calloc() can be used to allocate and already zero. In theory it is possible to have optimizations, maybe even in conjunction with the operating system to gain performance, but do not count on this, including because even the c/re/malloc() need to be the original. The pro malloc() is the cleaning of data.

In case you interpret the data as a string, and in C you can interpret as you like, a 1 byte zeroed will be a string 0 characters long, the \0 will be the terminator of string.

In C it is not appropriate to do cast of the outcome of malloc(), this can hide mistakes, so what you want is just:

char *char_commandout = calloc(1);

But overall this doesn’t make sense because you already know the content and it can’t change in a useful and correct way, even if you need a string 0 the ideal size is to do this statically, even used the Flyweight.

Another curiosity that makes no sense is to use

malloc(sizeof(char))

I put in the Github for future reference.

It is guaranteed by specification that char has always the size 1, in the background it is 1 byte. There are those who argue that one day can change, which is laughable, mainly because it is always said by an "experienced programmer".

Usually allocations in heap above 8 bytes, even 16 make very little sense and in the cases it does it would be the case to rethink whether it can do otherwise. In small things above the memory consumption to control the allocation is greater than the data itself. Of course, it’s not the only way to decide, there are things that need an indefinite allocation, but it’s also almost always possible to avoid this. In practice the allocation will be much larger than 1 byte, but you will only be able to access 1 byte, and then you try to access more than one before or after it, it will work, but for your sake hopefully the code breaks next.

Answer 2

Neither of the two. The malloc allocates the memory area, but does not wipe it. Therefore, any content that was abandoned there will continue there (this content is affectionately called rubbish). Therefore, the contents of the pointer after the malloc can be anything because it contains garbage.

It is recommended to write something in allocated memory to prevent you from accessing junk content, which would probably make the program behave incorrectly.

If you call malloc(1), a pointer pointing to 1 byte of allocated memory will be returned. It may even be that the malloc internally reserve a larger area for performance, but the only guarantee that exists is that 1 byte of reserved memory will be returned to you (reserved, but not cleaned), and that if you access beyond the limit (the second byte, at position 1)you will be accessing an unrestricted memory area (which may cause a segmentation failure, access the content of some other variable or read or write trash somewhere).