删除指向 const (T const *)的指针

我有一个关于常量指针的基本问题。不允许使用常量指针调用任何非常量成员函数。但是，我可以在一个常量指针上这样做:

delete p;

这将调用类的析构函数，该类实质上是一个非常量“方法”。为什么允许这样？难道只是为了支持这一点:

delete this;

还是有其他原因？

30082 次浏览
小开
最佳答案

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.

小开

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.

小开

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.


提交答案