deleting an array the wrong way [duplicate]

Question

Possible Duplicate:
How could pairing new[] with delete possibly lead to memory leak only?

I was always told that it's not safe to call delete on an array allocated with new[]. You should always pair new with delete and new[] with delete[].

So I was surprised to discover that the following code compiles and runs ok, in both Debug and Release mode under VS2008.

class CBlah
{
public:
    CBlah() : m_i(0) {}

private:
    int m_i;
};

int _tmain(int argc, _TCHAR* argv[])
{
    for(;;)
    {
        CBlah * p = new CBlah[1000]; // with []
        delete p;                    // no []
    }
    return 0;
}

It took me a while to figure out why this works at all, and I think it's just luck and some undefined behaviour.

BUT... it made me wonder... why doesn't Visual Studio pick this up, at least in the Debug memory manager? Is it because there's lots of code out there that makes this mistake and they don't want to break it, or do they feel it's not the job of the Debug memory manager to catch this kind of mistake?

Any thoughts? Is this kind of misuse common?

Answer 1

It will certainly compile ok, because there is no information in the pointer (compile-time) which will see if pointer points to array or what. For example:

int* p;

cin>>x;
if(x == 0)
  p = new int;
else
  p = new int [10];

delete p; //correct or not? :)

Now , about running ok. This is called undefined behavior in C++, that is, there is no guarantee what will happen - everything can run OK, you can get a segfault, you can get just wrong behavior, or your computer may decide to call 911. UB <=> no guarantee

Answer 2

It's undefined behavior and everything is fair in love, war and undefined behavior...:)