What happens if I write less than 12 bytes to a 12 byte buffer?

Question

Understandably, going over a buffer errors out (or creates an overflow), but what happens if there are less than 12 bytes used in a 12 byte buffer? Is it possible or does the empty trailing always fill with 0s? Orthogonal question that may help: what is contained in a buffer when it is instantiated but not used by the application yet?

I have looked at a few pet programs in Visual Studio and it seems that they are appended with 0s (or null characters) but I am not sure if this is a MS implementation that may vary across language/ compiler.

Answer 1

Take the following example (within a block of code, not global):

char data[12]; memcpy(data, "Selbie", 6); 

Or even this example:

char* data = new char[12]; memcpy(data, "Selbie", 6); 

In both of the above cases, the first 6 bytes of data are S,e,l,b,i, and e. The remaining 6 bytes of data are considered "unspecified" (could be anything).

Is it possible or does the empty trailing always fill with 0s?

Not guaranteed at all. The only allocator that I know of that guarantees zero byte fill is calloc. Example:

char* data = calloc(12,1);  // will allocate an array of 12 bytes and zero-init each byte memcpy(data, "Selbie"); 

what is contained in a buffer when it is instantiated but not used by the application yet?

Technically, as per the most recent C++ standards, the bytes delivered by the allocator are technically considered "unspecified". You should assume that it's garbage data (anything). Make no assumptions about the content.

Debug builds with Visual Studio will often initialize buffers with with 0xcc or 0xcd values, but that is not the case in release builds. There are however compiler flags and memory allocation techniques for Windows and Visual Studio where you can guaranteed zero-init memory allocations, but it is not portable.