Maybe you can do what you want with a little bit of preprocessor magic: #include <iostream> using namespace std; void* operator new (size_t size, const char* filename, int line) { void* ptr = new char[size]; cout << “size = ” << size << ” filename = ” << filename << ” line = ” << … Read more
One may try to replace new and delete operators for a number of reasons, namely: To Detect Usage Errors: There are a number of ways in which incorrect usage of new and delete may lead to the dreaded beasts of Undefined Behavior & Memory leaks. Respective examples of each are: Using more than one delete … Read more
It’s perfectly “safe” to delete a null pointer; it effectively amounts to a no-op. The reason you might want to check for null before you delete is that trying to delete a null pointer could indicate a bug in your program. Edit NOTE: if you overload the delete operator, it may no longer be “safe” … Read more
You can call clear, and that will destroy all the objects, but that will not free the memory. Looping through the individual elements will not help either (what action would you even propose to take on the objects?) What you can do is this: vector<tempObject>().swap(tempVector); That will create an empty vector with no memory allocated … Read more
It’s to support: // dynamically create object that cannot be changed const Foo * f = new Foo; // use const member functions here // delete it delete f; But note that the problem is not limited to dynamically created objects: { const Foo f; // use it } // destructor called here If destructors … Read more
Deleting a function is a C++11 feature: The common idiom of “prohibiting copying” can now be expressed directly: class X { // … X& operator=(const X&) = delete; // Disallow copying X(const X&) = delete; }; […] The “delete” mechanism can be used for any function. For example, we can eliminate an undesired conversion like … Read more
Stroustrup himself answers. An excerpt: C++ explicitly allows an implementation of delete to zero out an lvalue operand, and I had hoped that implementations would do that, but that idea doesn’t seem to have become popular with implementers. But the main issue he raises is that delete’s argument need not be an lvalue.
Use ::std::vector! Type* t = (Type*)malloc(sizeof(Type)*n) memset(t, 0, sizeof(Type)*m) becomes ::std::vector<Type> t(n, 0); Then t = (Type*)realloc(t, sizeof(Type) * n2); becomes t.resize(n2); If you want to pass pointer into function, instead of Foo(t) use Foo(&t[0]) It is absolutely correct C++ code, because vector is a smart C-array.
One question that the answers given so far don’t seem to address: if the runtime libraries (not the OS, really) can keep track of the number of things in the array, then why do we need the delete[] syntax at all? Why can’t a single delete form be used to handle all deletes? The answer … Read more
From the standard (5.3.5/2) : In the first alternative (delete object), the value of the operand of delete shall be a pointer to a non-array object or a pointer to a sub-object (1.8) representing a base class of such an object (clause 10). If not, the behavior is undefined. In the second alternative (delete array), … Read more