内存访问：为什么它不崩溃以及如何执行它？

Question

I expect the following code would generate certain memory access fault but it doesn't. Is there way to enforce it during compilation?

#include <iostream>
class B {};
class D : public B
{ public: int d; };

using namespace std;

main()
{
    B *pB = new B;
    ((D*)pB)->d = 2;
    cout << ((D*)pB)->d << endl;
}

As I understand, casting pointer to D does not change memory allocation so accessing "d" should be illegal, right?

Answer 1

Yes, accessing d is illegal, and your code has undefined behaviour.

There is no concept of "crash" in C++, so it does not make sense to ask for a portable way to create a "crash". If the behaviour of a program is undefined, it is not portable, and the language rules do not tell you what the program is doing.

Answer 2

It is illegal, but you are casting which tells the compiler you know what you are doing (don't do this without knowing the consequences) and cthat converts your pointer from B* to a D* while still actually being a B obhect at the location pointed to. So the results here are UNDEFINED since you are accessing out of bounds.

Also it would be good to prefer C++ style casts, vs C style casts (you are using a C-style cast) as they are generally a bit safer.

Answer 3

What you are doing usually won't cause a crash because of the way that memory allocation is typically handled behind the scenes.

And there are third party products that can check for errors of this kind (a buffer overrun in this case). Just search for "memory debuggers c++". Most tools for Windows are commercial, but there may be free ones available.