delete-operator

I have a pointer to a class, that have a pointer to a multidimensional array but I can't seem to delete it from memory when I need to or set it to NULL. #define X 10 #define Y 10 struct TestClass { public: int *pArray[X][Y]; }; // different tries, none working: delete Pointer_To_TestClass->pArray[0][0]; delete[] Pointer_To_TestClass->pArray[0][0] // or by simply: Pointer_To_TestClass->pArray[0][0] = NULL; I know the array has data because I can see the results on screen. Also check if it's NULL already, then doesn't try to delete it. Since I want to delete a pointer in another pointer - is

I'm new to C++ and from what I learned so far when you call delete on a pointer that points to something created on the heap then whatever is pointed by that pointer gets erased and the memory is freed, right? However when I tried this on a simple class: class MyClass { int _Id; public: MyClass(int id) : _Id(id) { std::cout << "$Constructing the damn thing! " << _Id << std::endl; } ~MyClass() { std::cout << "?Destructing the damn thing! " << _Id << std::endl; } void Go_XXX_Your_Self() { std::cout << "%OooooooooO NOOOOOO! " << _Id << std::endl; delete this; } void Identify_Your_Self() { std:

I'm dang certain that this code ought to be illegal, as it clearly won't work, but it seems to be allowed by the C++0x FCD. class X { /* ... */}; void* raw = malloc(sizeof (X)); X* p = new (raw) X(); // according to the standard, the RHS is a placement-new expression ::operator delete(p); // definitely wrong, per litb's answer delete p; // legal? I hope not Maybe one of you language lawyers can explain how the standard forbids this. There's also an array form: class X { /* ... */}; void* raw = malloc(sizeof (X)); X* p = new (raw) X[1]; // according to the standard, the RHS is a placement-new

I'm playing a little with memory dynamic allocation, but I don't get a point. When allocating some memory with the new statement, I'm supposed to be able to destroy the memory the pointer points to using delete . But when I try, this delete command doesn't seem to work since the space the pointer is pointing at doesn't seem to have been emptied. Let's take this truly basic piece of code as an example: #include <iostream> using namespace std; int main() { //I create a pointer-to-integer pTest, make it point to some new space, // and fulfill this free space with a number; int* pTest; pTest = new

Consider this classic example used to explain what not to do with forward declarations: //in Handle.h file class Body; class Handle { public: Handle(); ~Handle() {delete impl_;} //.... private: Body *impl_; }; //--------------------------------------- //in Handle.cpp file #include "Handle.h" class Body { //Non-trivial destructor here public: ~Body () {//Do a lot of things...} }; Handle::Handle () : impl_(new Body) {} //--------------------------------------- //in Handle_user.cpp client code: #include "Handle.h" //... in some function... { Handle handleObj; //Do smtg with handleObj... /