delete-operator

I have an class A which uses a heap memory allocation for one of its fields. Class A is instantiated and stored as a pointer field in another class ( class B . When I'm done with an object of class B, I call delete , which I assume calls the destructor... But does this call the destructor of class A as well? Edit: From the answers, I take that (please edit if incorrect): delete of an instance of B calls B::~B(); which calls A::~A(); A::~A should explicitly delete all heap-allocated member variables of the A object; Finally the memory block storing said instance of class B is returned to the

How can I realloc in C++? It seems to be missing from the language - there is new and delete but not resize ! I need it because as my program reads more data, I need to reallocate the buffer to hold it. I don't think delete ing the old pointer and new ing a new, bigger one, is the right option. f0b0s 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++

#include <queue> using namespace std; class Test{ int *myArray; public: Test(){ myArray = new int[10]; } ~Test(){ delete[] myArray; } }; int main(){ queue<Test> q Test t; q.push(t); } After I run this, I get a runtime error "double free or corruption". If I get rid of the destructor content (the delete ) it works fine. What's wrong? derekerdmann Let's talk about copying objects in C++. Test t; , calls the default constructor, which allocates a new array of integers. This is fine, and your expected behavior. Trouble comes when you push t into your queue using q.push(t) . If you're familiar with

I found the following snippet in the C++03 Standard under 5.3.5 [expr.delete] p3 : In the first alternative ( delete object ), if the static type of the object to be deleted is different from its dynamic type, the static type shall be a base class of the operand’s dynamic type and the static type shall have a virtual destructor or the behavior is undefined. In the second alternative ( delete array ) if the dynamic type of the object to be deleted differs from its static type, the behavior is undefined. Quick review on static and dynamic types: struct B{ virtual ~B(){} }; struct D : B{}; B* p =

class my_class { ... my_class(my_class const &) = delete; ... }; What does = delete mean in that context? Are there any other "modifiers" (other than = 0 and = delete )? Prasoon Saurav 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 this: struct Z { // ... Z(long long); // can initialize with an long long Z(long) =

I have a basic question regarding the const pointers. I am not allowed to call any non-const member functions using a const pointer. However, I am allowed to do this on a const pointer: delete p; This will call the destructor of the class which in essence is a non-const 'method'. Why is this allowed? Is it just to support this: delete this; Or is there some other reason? 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: {

I often see legacy code checking for NULL before deleting a pointer, similar to, if (NULL != pSomeObject) { delete pSomeObject; pSomeObject = NULL; } Is there any reason to checking for a NULL pointer before deleting it? What is the reason for setting the pointer to NULL afterwards? 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. The C++ standard guarantees that it is legal to use a null pointer in a delete-expression (§8