Re: Simple question on Pointers
Alan Carre <alan@twilightgames.com> wrote:
"Igor Tandetnik" <itandetnik@mvps.org> wrote in message
news:uJGwMnZVJHA.5032@TK2MSFTNGP05.phx.gbl...
Alan Carre <alan@twilightgames.com> wrote:
Yes, it would have been more precise to say that this->m_iSomeMember
is treated as const int&. You can't modify the object you have a
const reference to, but it doesn't mean that the object cannot
change: somebody else may have a non-const reference (or pointer) to
the same object and modify it through that.
Sure, I know. I mean we all provided examples of how to change it.
The only way to make something *really* const would be to somehow put
it into read-only memory
Well, as far as the compiler is concerned, it is sufficient to simply
declare the object const. You know, as in
const SomeClass sc;
sc.foo();
Any attempt to modify a const object (except for its mutable members)
triggers undefined behavior, at which point the compiler can wash its
hands of the whole mess, as no requirements are placed on it anymore.
I'm more interested now in looking at this mutable keyword that you
mentioned. Funny it never occured to me that there might actually be
some way to "exempt" certain members from acquiring the "const-ness"
of "this"... (assuming that's what it does).
That's essentially what it does.
It would be even better
if you could have a "mutable-once" attribute
You kind of sort of do: all fields are mutable in the constructor, even
if the object is declared const. That's your one shot at initializing a
const object.
Another way to achieve what you want without mutable is to note that
constness is shallow: if a const object has a member that is a pointer
(or reference), then the pointer itself is const (that is, it cannot be
changed to point to something else), but the object it points to doesn't
have to be. Consider:
class Lazy {
SomeData data;
bool initialized;
public:
Lazy() : initialized(false) {}
SomeData& getData() {
if (!initialized) {
initialzied = true;
data.Init();
}
return data;
}
};
class UseLazy {
Lazy* pLazy;
public:
UseLazy() : pLazy(new Lazy) {}
~UseLazy() { delete pLazy; }
const SomeData& getData() const {
return pLazy->getData();
}
};
const UseLazy constUser;
const SomeData& data = constUser.getData();
--
With best wishes,
Igor Tandetnik
With sufficient thrust, pigs fly just fine. However, this is not
necessarily a good idea. It is hard to be sure where they are going to
land, and it could be dangerous sitting under them as they fly
overhead. -- RFC 1925