delete-operator

I have an array in C++: Player ** playerArray; which is initialized in the constructor of the class it is in. In the destructor I have: delete playerArray; except when testing the program through Valgrind it says that there are some calls to delete to a void pointer: operator delete(void*) I want to test whether the playerArray is a void pointer before calling delete to avoid this error. Does anyone know how to do this? Perhaps you meant delete [] playerArray . You need the [] if the pointer is an array, not a single instance. Here's how operator delete is defined. void operator delete(void*)

The following code compiled with MSVC9.0 runs and outputs Destructor four times, which is logical. #include <iostream> class SomeClass { public: void CommitSuicide() { delete this; } void Reincarnate() { this->~SomeClass(); new (this) SomeClass; } ~SomeClass() { std::cout << "Destructor\n"; } }; int main() { SomeClass* p = new SomeClass; p->CommitSuicide(); p = new SomeClass; p->Reincarnate(); p->~SomeClass(); //line 5 p->CommitSuicide(); } I think the first 4 lines of code in main do not result in undefined behavior (although not entirely sure about the delete this; thing). I would like to

Previous header: "Must I replace global operators new and delete to change memory allocation strategy in third party code?" Short story: We need to replace memory allocation technique in third-party library without changing its source code. Long story: Consider memory-bound application that makes huge dynamic allocations (perhaps, almost all available system memory). We use specialized allocators, and use them everywhere ( shared_ptr 's, containers etc.). We have total control and power over every single byte of memory allocated in our application. Also, we need to link against a third-party

Cosider the following code: class Foo { Monster* monsters[6]; Foo() { for (int i = 0; i < 6; i++) { monsters[i] = new Monster(); } } virtual ~Foo(); } What is the correct destructor? this: Foo::~Foo() { delete [] monsters; } or this: Foo::~Foo() { for (int i = 0; i < 6; i++) { delete monsters[i]; } } I currently have the uppermost constructor and everything is working okey, but of course I cannot see if it happens to be leaking... Personally, I think the second version is much more logical considering what I am doing. Anyway, what is the "proper" way to do this? delete[] monsters; Is incorrect

This one made me think: class X; void foo(X* p) { delete p; } How can we possibly delete p if we do not even know whether X has visible destructor? g++ 4.5.1 gives three warnings: warning: possible problem detected in invocation of delete operator: warning: 'p' has incomplete type warning: forward declaration of 'struct X' And then it says: note: neither the destructor nor the class-specific operator delete will be called, even if they are declared when the class is defined. Wow... are compilers required to diagnose this situation like g++ does? Or is it undefined behavior? etarion From the

In the C++03 Standard, I see: 5.3.5 Delete 2 If the operand has a class type, the operand is converted to a pointer type by calling the above-mentioned conversion function, and the converted operand is used in place of the original operand for the remainder of this section. In either alternative, if the value of the operand of delete is the null pointer the operation has no effect. 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

I have discovered the classic new/delete mismatch error in our codebase as follows: char *foo = new char[10]; // do something delete foo; // instead of delete[] foo; Just how serious is this? Does it cause a memory leak or error? What are the consequences. We have some memory issues, but this doesn't seem serious enough to explain all our symptoms (heap corruption etc) EDIT: extra questions for clarity Does it just free the first member of the array? or Does it make the system lose track of the array? or Corrupt memory is some way? It's undefined behavior serious (it could work, it could crash

In this SO question is stated that this construct prevents stack allocation of instance. class FS_Only { ~FS_Only() = delete; // disallow stack allocation }; My question is, how does it prevents allocation? I understand, that is not possible to delete this instance, either explicitly or implicitly. But I think, that would lead to memory leak or run time error, respectively. Are compilers smart enough to sort this out and raise compiler error? Also why would one need this? The destructor of a variable with automatic storage duration (i.e. a local variable) would need to run when the variable's