Calling a const function from a non-const object

Question

I need to call a const function from a non-const object. See example

struct IProcess {    virtual bool doSomeWork() const = 0L; }; class Foo : public IProcess {       virtual bool doSomeWork() const {     ...   } };  class Bar { public:    const IProcess& getProcess() const {return ...;}    IProcess& getProcess() {return ...;}     void doOtherWork {     getProcess().doSomeWork();           } }; 

Calling

getProcess().doSomeWork(); 

will always results in a call to

IProcess& getProcess() 

Is there another way to call

const IProcess& getProcess() const  

from a non constant member function? I have so far used

const_cast<const Bar*>(this)->getProcess().doSomeWork(); 

which does the trick but seems overly complicated.

---

Edit: I should mention that code is being refactored and eventually only one function will remain.

const IProcess& getProcess() const  

However, currently there is a side effect and the const call may return a different instance of IProcess some of the time.

Please keep on topic.

Answer 1

const_cast is for casting away constness!

You're casting from non-const to const which is safe, so use static_cast:

   static_cast<const Bar*>(this)->getProcess().doSomeWork(); 

I mean techincally speaking you can cast in constness with const_cast, but it's not a pragmatic use of the operator. The purpose of new style casts (versus the old c-style cast), is to communicate the intent of the cast. const_cast is a code smell, and it's use should be reviewed at least. static_cast on the other hand is safe. But it's a matter of C++ style.

Or you can create a new (private) const method, and call that from doOtherWork:

  void doSomeWorkOnProcess() const { getProcess().doSomeWork(); } 

Using a const temporary is also an option (answer by "MSN"):

   const Bar* _this = this;    _this->getProcess().doSomeWork(); 

Answer 2

Avoid the cast: assign this to a const Bar * or whatever and use that to call getProcess().

There are some pedantic reasons to do that, but it also makes it more obvious what you are doing without forcing the compiler to do something potentially unsafe. Granted, you may never hit those cases, but you might as well write something that doesn't use a cast in this case.