How to force a call to a const qualified function overload? - c++

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;
}