How do I explicitly call an exception-throwing method in C++?

Question

I have a simple class:

class A {  public:   bool f(int* status = nullptr) noexcept {     if (status) *status = 1;     return true;   }   void f() {     throw std::make_pair<int, bool>(1, true);   } };  int main() {   A a;   a.f(); // <- Ambiguity is here! I want to call 'void f()' } 

I want to resolve ambiguity of a method call in favour of the exception-throwing method by any means.

The rationale behind such interface:

• To have the noexcept(true) and noexcept(false) interface,
• To allow optionally get extra information via a pointer in the noexcept(false) variant - while the noexcept(true) variant will always pack this information inside an exception.

Is it possible at all? Suggestions for a better interface are also welcome.

Answer 1

Having functions with this kind of signatures is obviously a bad design as you've found out. The real solutions are to have different names for them or to lose the default argument and were presented already in other answers.

However if you are stuck with an interface you can't change or just for the fun of it here is how you can explicitly call void f():

The trick is to use function pointer casting to resolve the ambiguity:

a.f(); // <- ambiguity is here! I want to call 'void f()'  (a.*(static_cast<void (A::*)()>(&A::f)))(); // yep... that's the syntax... yeah... 

Ok, so it works, but don't ever write code like this!

There are ways to make it more readable.

Use a pointer:

// create a method pointer: auto f_void = static_cast<void (A::*)()>(&A::f);  // the call is much much better, but still not as simple as `a.f()` (a.*f_void)(); 

Create a lambda or a free function

auto f_void = [] (A& a) {     auto f_void = static_cast<void (A::*)()>(&A::f);     (a.*f_void)(); };  // or  void f_void(A& a) {     auto f_void = static_cast<void (A::*)()>(&A::f);     (a.*f_void)(); };   f_void(a); 

I don't know if this is necessary better. The call syntax is definitely simpler, but it might be confusing as we are switching from a method call syntax to a free function call syntax.

Answer 2

Both versions f have different meanings.

They should have two different name, as:

• f for the throwing one, because using it means that your are confident on success, and failure would be an exception in the program.
• try_f() or tryF() for the error-return based one, because using it means that failure of the call is an expected outcome.

Two different meanings should be reflected in the design with two different name.