delete-operator

Why is there a delete[] ? From my understanding its to behave differently for arrays. However, why does it really exist? There's only free in C and no free_array. Also in syntax the only difference between delete var and delete []var is the [] which has no params (I'm not telling the length of the array). So why does delete[] really exist? I know someone will say you can overload delete and delete[] (at least i think that is possible) but lets say we are not overloading it. Why does it exist? Typically, for non-POD classes, a delete[] expression must call destructors on a variable number of

Let's say I want to make a type that cannot be constructed (don't ask why). struct Impossible { I could do it like this: Impossible() = delete; // disable automatically generated constructors, don't declare any others Impossible(const Impossible&) = delete; // I suppose this is redundant with nothing to copy or like this: Impossible(...) = delete; // explicitly disable all constructors or like this: template<typename... Ts> Impossible(Ts...) = delete; // explicitly disable all constructors, template version }; I guess I could ask the same thing about any function, not just constructors. Does

I have a char**, basically an array of strings, that I need to delete. What is the correct way of doing this to ensure all pointers are cleared up? char** StringList ; int nStrings ; .... for (int i = 0 ; i < nStrings ; i++) delete[] StringList[i] ; delete[] StringList ; Of course, it's simpler if you start with std::vector<std::string> Stringlist ; Then it's just StringList.clear() ; The rule of thumb is that you need one delete (or delete[] ) for each new (or new[] ) that you issued. So if you did: char **pp = new char*[N]; for (i = 0; i < N; i++) { pp[i] = new char[L]; } then you will need

Is there anything wrong when deleting an object like this in C++? MyCls* c = new MyCls(); void* p = (void*)c; delete (MyCls*)p; This as written is legal. The cast back to MyCls* is critical. Without that, you will invoke undefined behavior--the MyCls destructor will not be called, and other problems may arise as well (such as a crash). You must cast back to the correct type. Also note that this can be complicated if multiple inheritance is involved and multiple casts are used. Your casts must "match" in either direction. If your code is structured such that you won't know the type at the time

When you allocate an array using new [] , why can't you find out the size of that array from the pointer? It must be known at run time, otherwise delete [] wouldn't know how much memory to free. Unless I'm missing something? In a typical implementation the size of dynamic memory block is somehow stored in the block itself - this is true. But there's no standard way to access this information. (Implementations may provide implementation-specific ways to access it). This is how it is with malloc/free , this is how it is with new[]/delete[] . In fact, in a typical implementation raw memory