用未分配的内存块编写的C ++文件

Question

I was programming and a coding mistake caused problems:

ofstream myFile;
myFile.open("/home/guido/ejemplo.XX",ios::out | ios::binary | ios::trunc);
...
buffer = new char;
delete (buffer); 
//write into file with accidentally freed memory block
myFile.close();
...
ifstream sameFile;
sameFile.open("/home/guido/ejemplo.XX",ios::in | ios::binary);
//Crashes at previous line

Now, if I commented all code lines before ifstream sameFile; , the execution of sameFile.open(...) wouldn't fail. I'm not sure why does this happen. Does the program keep track of files that were illegaly written/read? What did the write(...) and close() functions do in this problem?

Answer 1

It's not really possible to know exactly why it crashed the way it did. That's why the C++ specifications calls it "undefined behavior": it is something that is outside of the language's definition. It might have executed correctly on some compilers/standard library implementations. It may have failed here due to memory corruption caused by the delete[] of a non-array pointer.

You could get a hardcore memory debugger (re: valgrind) to figure out the exact moment when the heap was corrupted. You might even see why the iostream object was damaged by this. But it wouldn't really help any, because it might fail for entirely different reasons on another system. Indeed, simply the act of introducing the memory debugger alone may change the behavior of where or when it fails.

Answer 2

The free isn't necessarily part of the problem, though that definitely makes it worse. You're overwriting the heap in one way or another when you read the file into the single byte buffer you allocated. When you try to open another file, it requires access to the heap to allocate blocks of memory, and will often crash because the heap has been corrupted. Particularly if you are in debug mode with memory checking on.