Logo Questions Linux Laravel Mysql Ubuntu Git Menu
 

Deleting a pointer to const (T const*)

People also ask

Can I delete a const pointer?

E2158 Operand of 'delete' must be non-const pointer (C++) It is also illegal to delete a pointer to a constant.

What is const int * const?

const int* const is a constant pointer to constant integer This means that the variable being declared is a constant pointer pointing to a constant integer. Effectively, this implies that a constant pointer is pointing to a constant value.

Can you make pointers to const?

A pointer to a const value (sometimes called a pointer to const for short) is a (non-const) pointer that points to a constant value. In the above example, ptr points to a const int . Because the data type being pointed to is const, the value being pointed to can't be changed. We can also make a pointer itself constant.

How do I get rid of const in C++?

The statement int* c = const_cast<int>(b) returns a pointer c that refers to a without the const qualification of a . This process of using const_cast to remove the const qualification of an object is called casting away constness.


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:

{
 const Foo f;
 // use it
} // destructor called here

If destructors could not be called on const objects we could not use const objects at all.


Put it this way - if it weren't allowed there would be no way to delete const objects without using const_cast.

Semantically, const is an indication that an object should be immutable. That does not imply, however, that the object should not be deleted.


Constructors and Destructors should not be viewed as 'methods'. They are special constructs to initialise and tear down an object of a class.

'const pointer' is to indicate that the state of the object would not be changed when operations are performed on it while it is alive.


I am not allowed to call any non-const member functions using a const pointer.

Yes you are.

class Foo
{
public:
  void aNonConstMemberFunction();
};

Foo* const aConstPointer = new Foo;
aConstPointer->aNonConstMemberFunction(); // legal

const Foo* aPointerToConst = new Foo;
aPointerToConst->aNonConstMemberFunction(); // illegal

You have confused a const pointer to a non-const object, with a non-const pointer to a const object.

Having said that,

delete aConstPointer; // legal
delete aPointerToConst; // legal

it's legal to delete either, for the reasons already stated by the other answers here.


Another way to look at it: the precise meaning of a const pointer is that you will not be able to make changes to the pointed-to object that would be visible via that or any other pointer or reference to the same object. But when an object destructs, all other pointers to the address previously occupied by the now-deleted object are no longer pointers to that object. They store the same address, but that address is no longer the address of any object (in fact it may soon be reused as the address of a different object).

This distinction would be more obvious if pointers in C++ behaved like weak references, i.e. as soon as the object is destroyed, all extant pointers to it would immediately be set to 0. (That's the kind of thing considered to be too costly at runtime to impose on all C++ programs, and in fact it is impossible to make it entirely reliable.)

UPDATE: Reading this back nine years later, it's lawyer-ish. I now find your original reaction understandable. To disallow mutation but allow destruction is clearly problematic. The implied contract of const pointers/references is that their existence will act as a block on destruction of the target object, a.k.a. automatic garbage collection.

The usual solution to this is to use almost any other language instead.