How to prevent implicit conversion from char array to bool

Question

struct Foo {
  void setBar(bool bar_) { bar = bar_; }
  bool bar;
};

int main() {
  Foo f;
  f.setBar("true");
}

The above code compiles successfully due to type conversion, even though a char array is passed where a bool is expected.

Is it possible to cause this code to fail compilation? (C++03 solution preferred, since the compiler at my workplace is ancient.)

I have looked at the following related questions on StackOverflow, but they don't quite address this problem. Preventing implicit conversion in C++, Why does the compiler choose bool over string for implicit typecast of L""?

You are **not** passing an `std::string`. You are passing a `const char[5]`. That decays to a `const char*`, which is converted to `bool`. — juanchopanza, Aug 27 '13 at 11:21
@juanchopanza Yes, sorry I realised that after posting. I have updated the question now. — Masked Man, Aug 27 '13 at 11:22

jrok · Accepted Answer · 2013-08-27T11:38:47.440

13

You can declare a function that takes const char* and don't provide a definition:

void setBar(const char*);

This will make it fail at link time. You're still left will all other implicit conversion, though - from any pointer to bool, integral to bool, floats to bool...

Another option:

struct Foo {
  void setBar(bool bar_) {}
private:
  template<typename T>
  void setBar(T bar) {}
};

This way you'll get an error about it being private if you call it with anything else than bool.

edited Aug 27 '13 at 11:38

answered Aug 27 '13 at 11:22

jrok

54,456
9
109
141

1

what about `private`? can we use that? – Afriza N. Arief Aug 27 '13 at 11:32
1

Fail at link time is not as nice as a fail at compile time. Hence private: void setBar(const void*); without definition. In addition I recomment not to use a template (imagine you have a wrapper class around a bool). – Aug 27 '13 at 12:52
does it prevent `setBar(42)` by chance? – Vladimir Gamalyan Nov 03 '20 at 12:18

juanchopanza · Answer 2 · 2013-08-27T11:41:37.137

10

One option would be to make setBar a template, and allow it only to work with bool:

#include <type_traits>

struct Foo 
{
  template <typename T>
  void setBar(T bar_) 
  { 
    static_assert(std::is_same<bool,T>::value, "not bool");
    bar = bar_;         
  }
  bool bar;
};

int main() {
  Foo f;
  f.setBar(true);   // OK
  f.setBar("true"); // Error
  f.setBar(1);      // Error
}

Alternatively, you can use SFINAE with std::enable_if to the same effect, although the compiler warning might be less easy to read:

struct Foo 
{
   template<class T ,
            class = typename std::enable_if<std::is_same<bool,T>::value>::type >
    void setBar(T bar_)
    { 
      bar = bar_;
    } 
  bool bar;
};

edited Aug 27 '13 at 11:41

answered Aug 27 '13 at 11:29

juanchopanza

223,364
34
402
480

1

This, and you can use BOOST_STATIC_ASSERT for C++03 solution. – jrok Aug 27 '13 at 11:30
I would mention `std::enable_if` too. – lapk Aug 27 '13 at 11:32
1

@PetrBudnik Good idea, I added an example. – juanchopanza Aug 27 '13 at 11:42

willj · Answer 3 · 2013-08-27T16:58:07.093

There is a common idiom that both avoids this issue and provides other advantages. Instead of using bool, you can create a custom type that more clearly describes the state that it represents.

The type bool represents only a generic value of true or false, while in actual usage you are overloading these states to mean something more specific. Here's an example using an enum to define a new type:

enum Bar { ok, foobar };

struct Foo {
  void setBar(Bar bar_) { bar = bar_; }
  Bar bar;
};

int main() {
  Foo f;
  f.setBar(foobar); // ok
  f.setBar("true"); // error
}

This still allows implicit conversion from any arithmetic or floating type. To avoid this, you can use C++11's enum class, or roll your own strongly-typed bool like this:

template<class Tag>
struct Bool { bool value; };

typedef Bool<struct BarTag> Bar;
const Bar Ok = { false };
const Bar FooBar = { true };

How to prevent implicit conversion from char array to bool

3 Answers3

Linked