code like this:
int * a = new int(0);
int * b = new int(0);
int * c = new int[2];
int * d = new int[2];
int * e = new int[1];
delete a;
delete []b;
delete c;
delete []d;
delete e;
The compiler does not prompt "error" or "warning"(vs 2005 at warning level 4).
But such use of "delete" and "delete []" is incorrect according the book(line "delete []b;" and "delete c;").
Is that so?what problem will cause?
Well, it's undefined behaviour, so technically, while there is no guarantee it will work, there is no guarantee it will fail, either.
I suggest using it the right way, the reason it worked here is probably because int is a simple data type. If you were using a more complicated class, the new[] will create each element of the array as expected, and the delete[] will call the destructor of each element, whereas the delete would just free the array without calling the destructor for each element, which may result in a memory leak and possibly much worse errors. Again, just because it works, doesn't mean it's correct.
Also, I suppose the lack of compiler warnings comes from the fact that it's not always possible to distinguish an array from a pointer to a single object, but I could be wrong on this.
Is that so?what problem will cause?
Maybe nothing. Maybe a memory leak. Maybe random memory corruption anywhere in your program. Maybe an instant crash.
Always make sure you use the correct 'delete' code depending on what kind of 'new' code was used.
void foo(int x)
{
int *p;
if ((x % 2) == 0)
p = NULL;
else if ((x % 3) == 0)
p = new int(0);
else if ((x % 5) == 0)
p = new int[2];
if ((x % 7) == 0)
delete p;
else if ((x % 11) == 0)
delete[] p;
}delete what you new, and delete [] what you new [].
Welcome to the land of C++, where you can completely shoot your leg off and introduce massive bugs without any errors from the compiler. The compiler doesn't force you to Do The Right Thing (and it many cases, it can't deduce what the Right Thing is to enforce it even if it wanted to). It assumes you know what you should and should not do, and only enforces a very minimal set of rules (the other rules aren't enforced, but you're still expected to follow them, like this rule we're talking about here).
If you don't follow these rules, anything can happen, from your program continuing to work as if everything was fine (this is the worst case, because it hides the error), to crashing the program (this is the best case, because now it's obvious there's a problem), to a black hole opening up and swallowing us all (ok, maybe this is the worst case). It's called "undefined behavior."
Now, as for why you have to use delete [] when you use new [] (and can't just use delete for everything), the main reason that I can think of is memory book keeping by the compiler. How does the system know how much memory to free when you say delete (or delete [])? There's some book keeping of memory done behind the scenes, and the compiler is allowed to do book keeping however it wants, pretty much. It's entirely possible that the compiler decides to use different types of book keeping, depending on whether you used new or new []. Thus, you need to make sure the right book keeping is undone when you call delete.
In combination with the book keeping described above, when you destroy an object its destructor gets called. delete signals that there is only one object being destroyed, and thus only one destructor needs to be called. However, delete [] signals that there are one or more objects being destroyed, and thus potentially many destructors need to be called. Mixing the two incorrectly is just asking for some bad mojo.
There might be additional reasons as for why its important to match delete with new and delete [] with new [], but I'd consider these as the important base reasons why.
Ultimately, though, you can sum it up and just say "because the C++ standard says so."
the delete[] will call the object's destructor functionThe previously posted answers were meant just as much for you as for the original topic-poster.
The only difference between delete and delete[] is, that in the latter case the object destructor isn't called for the pointer address only but all subsequent "positions" in the array until the end of the memory block is reached. In theory it should be save to always call delete[] since the memory block would have only sizeof(object). But it's better to follow the rules to ensure compiler compability. You should also consider using dynamic arrays like std::vector which does the gritty things for you.
