Is there a way to avoid inadvertently passing a non-boolean argument to a boolean parameter?

Question

I got bit by a C++ type-safety issue today, and I'm wondering if there is a good way to get the compiler to detect this issue at compile time. Consider this example code:

class Bar
{
public:
   void Foo(bool arg1 = false, int arg2 = 10, int arg3 = 20)
   {
      [...]
   }
};

int main(int argc, char ** argv)
{
   int x = 40, y = 50;
   Bar b;
   b.Foo();            // correct usage
   b.Foo(true, x, y);  // correct usage
   b.Foo(x, y);        // problem:  compiles but won't do what the caller expects
}

As shown in the final call to b.Foo(), the issue is that it's easy to forget to supply the first argument, and in that case things go wrong in a way that is not caught by the compiler.

What would be nice is if I could get the compiler to say something like "ERROR, non-boolean value was supplied to a boolean parameter". That would force the developer to examine the code, and if he really wanted to pass in x as a boolean, he'd have to pass in (x!=0) instead.

This seems like a good place to use the "explicit" keyword, but AFAICT that keyword doesn't work for function arguments.

(I realize that this sort of issue could be avoided by not supplying default values for the arguments, but default values can be quite handy)

Answer 1

You may provide deleted overloads:

class Bar
{
public:
   void Foo(bool arg1 = false, int arg2 = 10, int arg3 = 20)
   {
      [...]
   }

    template <typename T>
    void Foo(T&&, int = 10, int = 20) = delete;
};

As the template method would be an exact match for non bool parameter.