#include 

class Goblin final {
 public:
  enum class Wear : bool { NoHat = false, Hat = true };

  static bool wearAHat(const Wear obj) {
    return static_cast<std::underlying_type::type>(obj);
  }

  static Wear wearAHat(const bool is_wearing_hat) {
    return static_cast(is_wearing_hat);
  }

  explicit Goblin(const Wear wear) : wear_{wear} {
  }

  bool isWearingHat() const { return wearAHat(wear_); }

 private:
  Wear wear_;
};

std::ostream& operator<<(std::ostream& os, Goblin::Wear obj) {
  switch (obj) {
    case Goblin::Wear::NoHat:
      os << "NoHat";
      break;
    case Goblin::Wear::Hat:
      os << "Hat";
      break;
    default:
      os.setstate(std::ios::failbit);
  }

  return os;
}

int main() {
  // Strongly-typed initialization.
  const Goblin bill{Goblin::Wear::Hat};

  // Conversion to bool.
  std::cout << "Goblin::Wear::NoHat corresponds to: "
            << Goblin::wearAHat(Goblin::Wear::NoHat) << 'n';
  std::cout << "Goblin::Wear::Hat corresponds to: "
            << Goblin::wearAHat(Goblin::Wear::Hat) << 'n';
  std::cout << "is bill wearing a hat? " << std::boolalpha
            << bill.isWearingHat() << 'n';

  // Conversion from bool.
  const Goblin john{Goblin::wearAHat(false)};
  std::cout << "is john wearing a hat? " << std::boolalpha
            << john.isWearingHat() << 'n';
  std::cout << "false corresponds to: " << Goblin::wearAHat(false) << 'n';
  std::cout << "true corresponds to: " << Goblin::wearAHat(true) << 'n';
}

One can argue that is overkill, but I think it is almost always worth the effort. The caller has to invoke `Goblin{Goblin::wearAHat(true)}` instead of `Goblin{true}` and that is a good thing, imo.

Off-topic: Disqus syntax highlighting does not work properly.

Oh right yes, it seems to be a proposal http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0329r0.pdf. Thanks for sharing!

I just found out that this feature is called “Designated initializers” and is not well supported on gcc – just clang.

example:
struct object {
struct params {
bool some_value1 = true;
bool some_value2 = true;
};
object(const params& p) {
if (p.some_value1) {
cout << "some_value1 is set" << endl;
}
if (p.some_value2) {
cout << "some_value2 is set" << endl;
}
}
};

int main() {
object foo({ .some_value2 = false });
}

Thanks for your suggestion. Do you have an example of C++ code that uses that syntax and compiles?

Interesting! Do you know where to read more about this syntax check by clang?

I think this is an interesting trade-off. On one hand you can’t receive a bool coming from raw data (GoblinUserInput) (but you could argue this makes sense and you’d need an indirection to transform raw data into business data). And on the other hand, like you’re saying, you can’t pass a bool that has another meaning. Thanks for sharing your opinion.

?

Right, ‘explicit’ is still desirable to avoid IsWearingAHat->Goblin implicit constructions if that’s something you don’t want. (There might be other scenarios where implicit construction would be wanted).

But I initially thought it was necessary so that the constructor woouldn’t accept a pure bool alone, but I was incorrect about that part.