Too much Memory is Allocated to `char* x = new char[32]` - c++

Question

#include <iostream>
using namespace std;
struct my_chunk
{
int size;
char* data;
};
my_chunk* make_chunk()
{
my_chunk* new_chunk = new my_chunk;
new_chunk->size = 32;
new_chunk->data = new char[32];
new_chunk->data[0] = 'h';
new_chunk->data[1] = 'e';
new_chunk->data[2] = 'l';
new_chunk->data[3] = 'l';
new_chunk->data[4] = 'o';
new_chunk->data[5] = '5';
new_chunk->data[5] = 'h';
new_chunk->data[6] = 'e';
new_chunk->data[7] = 'l';
new_chunk->data[8] = 'l';
new_chunk->data[9] = 'o';
new_chunk->data[10] = 'h';
new_chunk->data[11] = 'e';
new_chunk->data[12] = 'l';
new_chunk->data[13] = 'l';
new_chunk->data[14] = 'o';
new_chunk->data[15] = 'h';
new_chunk->data[16] = 'e';
new_chunk->data[17] = 'l';
new_chunk->data[18] = 'l';
new_chunk->data[19] = 'o';
new_chunk->data[20] = 'h';
new_chunk->data[21] = 'e';
new_chunk->data[22] = 'l';
new_chunk->data[23] = 'l';
new_chunk->data[24] = 'o';
new_chunk->data[25] = 'h';
new_chunk->data[26] = 'e';
new_chunk->data[27] = 'l';
new_chunk->data[28] = 'l';
new_chunk->data[29] = 'h';
new_chunk->data[30] = 'e';
new_chunk->data[31] = 'l';
return new_chunk;
}
void main()
{
my_chunk* same_chunk;
same_chunk = make_chunk();
std::cout << same_chunk->data;
std::cout << std::endl;
system("pause");
}
That is the simple code I compile. No matter the size I size my char* data to it adds some form of padding. It does not appear to be an alignment issue, perhaps I am wrong on that point however.
What I know is that when I size my char* data = new char[size] I can easily access beyond element [size]. The fact I can access beyond and set those elements suggests to me a massive problem has occurred.
For clarification that means in my code above, I could add a line that goes new_chunk->data[38] = 'x' without any error, crash, or anything. I have tested it, it works fine.
This isn't a huge issue, as I am given enough memory to fit my data. The only problem is that I don't understand why this is happening, and would prefer to fix it.
Also this is the output of my Program:
hellohellohellohellohellohellhel²²²²½½½½½½½½¯■¯■
Press any key to continue . . .
Edit:
This has exploded with helpful insights, perhaps I can get one more bit of help related to all this.
Why does Visual Studio 2013 show the char* beyond its length? It shows the "hellohellohellohellohellohellhel²²²²½½½½½½½½¯■¯■" which was suggesting to me that it was allocating too much memory. As a side note, the output is always the same (so far). This is when I debug, looking at the variables it shows exactly what is output.

Answer 1

char* need a trailing '\0' to be printed properly by std::cout. So this line std::cout << same_chunk->data; will iterate in memory till it find a zero...
That can cause a crash, printing garbage, ...
By the way there is no bound checking for pointer access in C++ so whenever you write data[X] the program try to go to adresse of data + X time the size of one data element (here char).
If you want bound access (and you want it) use either a std::string (neat for characters) or a std::vector (neat for anything).

Answer 2

Here's another perspective based on a lower-level view:
When you call new (or malloc), the library (libc?) will request some memory from the OS. This memory is most likely in page form (ie. 4K, 2M, etc bytes large). Depending on the algorithm that the library uses to manage dynamic memory, a couple of things can happen:
Your data[] pointer happens to be right at the back edge of this page, and you get a page fault (program crash, expected behaviour)
More likely, the library allocated you some space in the middle of a page. Since C++ doesn't do bounds checking (as answered by others), it treats this data* pointer as a pointer to a list of bytes in memory. Since the granularity of the space allocated to the heap is rather large, you can be accessing mapped pages (ie. no program crash), that have rubbish values (ie. uninitialised values).
Also, another thing to note is that when you request a block of memory 32 bytes long, nothing dictates you get one that is exactly 32 bytes long. new[] might give you a region 1024 bytes long, or 400000 bytes long. The only guarantee is that it is at least 32 bytes long. Therefore, this is another reason (although not the main reason) that your program doesn't crash.

Answer 3

C++ doesn't really check to make sure an array index is within the initial chunk of memory allocated for the array. When you are accessing the "extra" memory, you're basically just accessing some unrelated memory and casting it as a character. It isn't ALLOCATED as part of the array, just ACCESSIBLE as if it were. And assigning values to those random memory locations is just overwriting memory randomly... Bad idea.

Answer 4

C and C++ do not do bounds checking. So basically you just got lucky that you didn't get a segfault when you accessed a location past the bounds of your allocated memory.
the [38] notation basically says move to the equivalent address of data + 38 * sizeof(char *). So if this space were to be marked as poison, you woulda been out of luck.