Re: can a const pointer be deleted?
On Dec 2, 8:05 pm, Maxim Yegorushkin <maxim.yegorush...@gmail.com>
wrote:
On Dec 2, 1:55 pm, abir <abirba...@gmail.com> wrote:
Hi,
In the std containers erase takes a const_iterator.
This is not so.
In std containers erase member function is a non-const member
function, because it changes the container contents. It would not be
logical for that function to accept const_iterator.
Though the MSDN document (I am using VC9 express) says it it an
iterator
http://msdn.microsoft.com/en-us/library/ceh559x2(VS.80).aspx
and SGI is saying the same, the code says it is an const iterator and
thus,
std::vector<int> v;
v.push_back(1);
const std::vector<int>& cv = v;
std::cout<<typeid(cv.begin()).name()<<"\n";
v.erase(cv.begin());
This code runs perfectly, and indeed cv.begin() is const_iterator and
i think
it is not possible to convert a const_iterator to iterator, though the
other way is possible.
So not sure if i am missing something or it is bug from msvc side.
Will check it on gcc.
I have my own container and there const_iterator is a const pointer
to the item.
I want to free the memory for the item on erase (i.e both destroy &
deallocate).
However deallocate function for allocator (and so delete, free etc)
takes a pointer rather than
a const pointer. Is that mean i have to cast it back to a pointer?
Make your_container::erase() accept non-const iterators.
That is what i do. But my point is, if const pointer can be destroyed
(though can't be modified)
so why can't const_iterator do the same?
I was looking at std::list. There even a const_iterator returns a non
const node pointer (not very sure though).
Also how this works ? does the operator delete automatically cast it
to a non const type ?
const testobj* to = new testobj(1,1);
delete to;
There are two different things in C++ named delete: a) delete-
expression; b) operator delete. Here you are using delete-expression
and it ignores const-ness and volatile-ness. What delete-expression a)
does is it calls the destructor of the object and then invokes
operator delete b).
In C, while this works
char* ch = (char*)std::malloc(5);
std::free(ch);
for a const pointer i explicitly need to cast it back like,
const char* ch = (const char*)std::malloc(5);
std::free((char*)ch);//or std::free(void*)ch);
In C++ the equivalents of malloc/free are operator new/delete, not new/
delete-expression:
#include <new>
int main()
{
char const* c = (char const*)operator new(5);
operator delete((void*)c); // need a cast here
}
I understand that. What i want to know whether delete expression after
calling destructor
implicitly cast the const pointer to non const before calling delete
operator? as delete operator
takes a void* (and not a const void*) and the pointer available after
destruction is const T* (T is the object type) which can be converted
to const void* but not to void* in 'ordinary cases'.
It seems delete expression, as you said does that extra thing to
remove const-ness and volatile
from the pointer before calling delete operator (Though i don't know
why!).
Thanks for reply.
abir
--
Max