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."