I have yet to generally confirm this, or yet did any real extensive testing to confirm that what I have encountered works, in-general, but it appears to be the case at least in the cases encountered.
(I can't actually seem to find any mention of it existing, like somehow encountering a feature which should not exist?...).
(ADD 4: Turns out it was much more limited, see end of post...).
basically, what happened:
I had looked around on the internet, and recently saw graphs showing that newer versions of MSVC produced code which was notably faster than the version I was using (Platform SDK v6.1 / VS 2008).
I was like, "hell, I think I will go download this, and try it out...".
so, long story short (on this front, basically went and downloaded and installed a bunch of stuff and ended up needing to reboot computer several times), I got my stuff to build on the new compiler (Visual Studio Express 2013).
except, in several cases, it crashed...
the thing was not just that it crashed, but how it crashed:
it was via bounds-check exceptions (I forget the name).
not only this, but on the actual lines of code which were writing out of bounds...
and, this occurred in several places and under several different scenarios.
in past compilers, one may still get a crash, but it was usually after-the-fact (when the function returns, or when "free()" is called), but this is different.
looking around, I couldn't find much information on this, but did run across this paper (from MS Research):
this implies that either this (or maybe something similar) has actually been put into use in compilers deployed "in the wild", and that bounds-checking for C code, apparently, does now actually exist?... (ADD4: No, it does not, I was incorrect here...).
compiler: Visual Studio Express 2013 RC (CL version: 18.00.20827.3);
code is compiled with debug settings.
ADD: ok, turns out this is a "Release Candidate" version, still can't find any reference to this feature existing.
I may have to go do some actual testing to confirm that this is actually the case, and/or figure out what else could be going on here... I am confused, like if something like this were added, wouldn't someone write about it somewhere?...
ADD2 (from VS, for one of the cases):
0FD83E3C sub eax,1
0FD83E3F mov dword ptr [ebp-0A4h],eax
0FD83E45 cmp dword ptr [ebp-0A4h],40h
0FD83E4C jae BASM_ParseOpcode+960h (0FD83E50h)
0FD83E4E jmp BASM_ParseOpcode+965h (0FD83E55h)
0FD83E50 call __report_rangecheckfailure (0FD9C978h)
0FD83E55 mov eax,dword ptr [ebp-0A4h]
0FD83E5B mov byte ptr b[eax],0
so, this one is a statically-inserted bounds-check.
(dunno about the others...).
ADD3 (this case has an explanation at least):
ADD4: more testing, it does not apply to memory allocated via "malloc()", which still does the crash on "free()" thing, rather than crash immediately.
the bounds-checking apparently only applies to arrays which the compiler knows the size for, but does not apply to memory accessed via a raw pointer.