How to force a call to a const qualified function overload?

Question

I'm trying to call const function inside a class, but a non-const function with the same name exists.

Note: I can't just change names.

class MyQuestion
{
 void fun()
 {
   cout<<"a"; 
 }

 void fun()const
 { 
   cout<<"b"; 
 }

 void call()
 {
   fun();//<how to call fun() const?
 }
};

Answer 1

Option #1:

Call that function through a pointer to a const qualified type:

void call()
{
    static_cast<const MyQuestion*>(this)->fun();
    //          ~~~~^
}

c++11:

void call()
{
    const auto* that = this;
    //~~^
    that->fun();
}

c++17:

void call()
{
    std::as_const(*this).fun();
    //   ~~~~~~~^
}

Option #2:

Make the calling function a const-qualified one:

void call() const
//          ~~~~^
{
    fun();
}

DEMO

Answer 2

You have to call the function on a const pointer. For this, I recommend to create a local pointer variable:

const auto *c = this;
c->fun();   // calls fun() const

fun();      // calls fun()

Live Demo

---

If you need that often, and/or if you don't want to use a local variable, you could also introduce a private helper function which returns a const this pointer:

const MyQuestion *const_this() const {
    return this;
}

and then call fun like this:

const_this()->fun();   // calls fun() const

fun();                 // calls fun()

Live Demo

---

Yet another option is to write a make_const function which performs a cast to a const pointer without the need to mention the class name (it's basically a static_cast to a const pointer of a deduced type):

template <typename T>
const T* make_const(T *ptr) {
    return ptr;
}

and then call fun like this:

make_const(this)->fun();    // calls fun() const

fun();                      // calls fun()

Live Demo

---

For the sake of argument (I don't recommend the following), combining with the suggestion above, you could also introduce a global macro which expands to make_const(this):

#define  const_this  make_const(this)

and then call fun like this:

const_this->fun();   // calls fun() const

fun();               // calls fun()

Live Demo

Answer 3

I would like to add another possible solution to the excelent ones already posted.

You can help the compiler to choose the correct overload using a function pointer with the expected signature:

// Pointer to the version of fun with const
void (MyQuestion::*f)()const = &MyQuestion::fun;
(this->*f)(); // This would call the const fun

See the demo here, or the full code below:

struct MyQuestion
{
    void fun()
    {
        std::cout<<"a"; 
    }

    void fun()const
    { 
        std::cout<<"b"; 
    }

    void call()
    {
        void (MyQuestion::*f)()const = &MyQuestion::fun;
        (this->*f)();
    }
};

Why does this work?

Well, the type of the f pointer is void (MyQuestion::*)()const which is the same of MyQuestion::foo()const but not the same of MyQuestion::foo(), so when you take te address of the function &MyQuestion::fun the pointer f could only point to the const version.

Answer 4

how about overloading call() itself. Following implementation does the job. I m guessing that it is what you want to implement.

#include <iostream>
using namespace std;

class A
{
public:
    void fun() { cout << "non" << endl; }
    void fun() const { cout << "const" << endl; }

    void call() { fun(); }
    void call() const { fun(); }
};

int main()
{
    A a;
    a.call();

    const A b;
    b.call();
    return 0;
}