Suppression d'un pointeur vers const (T const *)

J'ai une question de base concernant les pointeurs const. Je ne suis pas autorisé à appeler des fonctions membres non const à l'aide d'un pointeur const. Cependant, je suis autorisé à le faire sur un pointeur const:

delete p;

Cela appellera le destructeur de la classe qui est essentiellement une «méthode» non-const. Pourquoi est-ce permis? Est-ce juste pour soutenir ceci:

delete this;

Ou y a-t-il une autre raison?

C'est pour soutenir:

// dynamically create object that cannot be changed
const Foo * f = new Foo;

// use const member functions here

// delete it
delete f;

Mais notez que le problème ne se limite pas aux objets créés dynamiquement:

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

Si les destructeurs ne pouvaient pas être appelés sur les objets const, nous ne pourrions pas du tout utiliser d'objets const.

En d'autres termes, si ce n'était pas autorisé, il n'y aurait aucun moyen de supprimer des objets const sans utiliser const_cast.

Sémantiquement, const est une indication qu'un objet doit être immuable. Cela n'implique cependant pas que l'objet ne doit pas être supprimé.

Je ne suis pas autorisé à appeler des fonctions membres non const à l'aide d'un pointeur const.

Oui, vous l'êtes.

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

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

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

Vous avez confondu un pointeur const vers un objet non const, avec un pointeur non const vers un objet const.

Ayant dit cela,

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

il est légal de supprimer non plus, pour les raisons déjà indiquées par les autres réponses ici.

Les constructeurs et les destructeurs ne doivent pas être considérés comme des «méthodes». Ce sont des constructions spéciales pour initialiser et détruire un objet d'une classe.

«const pointer» indique que l'état de l'objet ne sera pas modifié lorsque des opérations sont effectuées sur celui-ci alors qu'il est en vie.

Une autre façon de voir les choses: la signification précise d'un pointeur const est que vous ne pourrez pas modifier l'objet pointé qui serait visible via ce pointeur ou tout autre pointeur ou référence au même objet. Mais lorsqu'un objet est détruit, tous les autres pointeurs vers l'adresse précédemment occupée par l'objet maintenant supprimé ne sont plus des pointeurs vers cet objet . Ils stockent la même adresse, mais cette adresse n'est plus l'adresse d'aucun objet (en fait elle pourra bientôt être réutilisée comme adresse d'un objet différent).

Cette distinction serait plus évidente si les pointeurs en C ++ se comportaient comme des références faibles, c'est-à-dire que dès que l'objet est détruit, tous les pointeurs existants vers lui seraient immédiatement positionnés sur 0. (C'est le genre de chose considérée comme trop coûteuse à l'exécution pour l'imposer à tous les programmes C ++, et en fait, il est impossible de la rendre entièrement fiable.)

MISE À JOUR : En lisant cela neuf ans plus tard, c'est avocat-ish. Je trouve maintenant votre réaction initiale compréhensible. Interdire la mutation mais permettre la destruction est clairement problématique. Le contrat implicite des pointeurs / références const est que leur existence agira comme un blocage lors de la destruction de l'objet cible, c'est-à-dire le garbage collection automatique.

La solution habituelle à cela est d'utiliser presque n'importe quelle autre langue à la place.