Re: mutable vs const_cast, which is better to modify field from const function?
On Jul 9, 7:19 am, Qi <n...@no.com> wrote:
It's not rare to lazy initialize member field in getter functions which
are const function.
class SomeClass {
public:
MyObject * getMyObject() const {
if(! this->myObject) {
this->myObject = create=
the object;
}
return this->myObject;
}
private:
MyObject * myObject;
};
To be able to modify myObject in the getter function, we can
either,
1, Use mutable on myObject.
mutable MyObject * myObject;
or
2, Use const_cast to cast away constness from "this".
const_cast<SomeClass *>(this)->myObject = create the object;
Both methods have their own pros and cons, that's why I can't
decide which is better.
Method 1 (mutable),
Pros:
It's quite nature. Since myObject can be modified by a
const function, it's natural that it's mutable.
Cons:
A, "mutable" makes myObject to be changable to all const
functions. This is the problem. It should not be able to be
modified by any const functions except the lazy initialization
(the getter).
B, Any one reading the code may misunderstand that myObject
is really mutable while it's not.
Method 2 (const_cast),
Pros:
The effect is only limited to the getter function, any other
const functions can't modify myObject.
Cons:
A, Casting a const "this" to non-const looks so ugly and not
natural.
B, And a const function being able to modify a non-mutable member
is not natural too.
My questions:
1, Which method do you prefer to implement lazy initialization?
2, I think both methods are quite standard C++ (03), right?
If not, please point out.
Thanks
--
WQ
Deviating as little as possible from your code and addressing ONLY
your question, here is my suggestion:
-------------------------------------------
struct MyObject{};
struct SomeClass
{
SomeClass():myObject(0){}
const MyObject * getMyObject()const
{
return getMyObject_impl();
}
MyObject * getMyObject()
{
return getMyObject_impl();
}
private:
const MyObject * getMyObject_impl()const
{
if(!myObject)
{
myObject = new MyObject();
}
return myObject;
}
MyObject * getMyObject_impl()
{
if(!myObject)
{
myObject = new MyObject();
}
return myObject;
}
mutable MyObject * myObject;
};
-------------------------------------------------
So as long as all your other member functions access myObject via the
getMyObject_impl methods it should be ok.
Rgds
N