It’s actually the statement after the one you mark as causing the program to crash that causes the program to crash! You must pass the same pointer to delete[] as you get back from new[]. Otherwise the behaviour of the program is undefined.
Note: This answer applies to C++03, and it seems like the behavior was changed in C++11 and higher so that this is now undefined behavior. It turns out that in this particular case the code is legal, but you’re ε-away from undefined behavior. The C++03 standard defines the notion of the “lifetime” of an object … Read more
This is undefined behaviour, as there’s no way to reliably prove that memory behind the pointer was allocated correctly (i.e. by new for delete or new[] for delete[]). It’s your job to ensure things like that don’t happen. It’s simple when you use right tools, namely smart pointers. Whenever you say delete, you’re doing it … Read more
Simple rules to follow: for each allocation, there has to be a deallocation (ex1 is therefore wrong) what was allocated using new should be freed using delete, using new[] should be deallocated using delete[] and using malloc should be deallocated using free (ex3 is therefore wrong) Conclusion, ex2 is OK.
The rule is very simple: every object created with new must be destroyed exactly once with delete; every array created with new[] must be destroyed exactly once with delete[]; everything else must not be deleted. So your code is correct; you are deleting mc after creating it with new, and not deleting the members which … Read more
Unfortunately, they don’t know what delete to use therefore they use delete. That’s why for each smart pointer we have a smart array counterpart. std::shared_ptr uses delete std::shared_array uses delete[] So, your line std :: unique_ptr <int> x (new int [2]); actually causes undefined behavior. Incidentally, if you write std :: unique_ptr<int[]> p(new int[2]); ^^ … Read more
The delete operator deallocates memory and calls the destructor for a single object created with new. The delete [] operator deallocates memory and calls destructors for an array of objects created with new []. Using delete on a pointer returned by new [] or delete [] on a pointer returned by new results in undefined … Read more
If the user’s goal was to create an object in some memory location, then new seemed like a natural approach since forwarding references, variadic templates and placement new were not a thing back in those days. As correctly pointed out by @T.C. templates were released in 1990 and placement new in 1989. Variadic templates on … Read more
Ugh, my sympathy. This is going to depend a lot on your compiler, your libc, etc. Some rubber-meets-road strategies that have “worked” to varying degrees for us in the past (/me braces for downvotes) are: The operator new / operator delete overloads you suggested — although note that some compilers are picky about not having … Read more
There’s no new/delete expression in C. The closest equivalent are the malloc and free functions, if you ignore the constructors/destructors and type safety. #include <stdlib.h> int* p = malloc(sizeof(*p)); // int* p = new int; … free(p); // delete p; int* a = malloc(12*sizeof(*a)); // int* a = new int[12]; … free(a); // delete[] a;