如何阻止bool与int间的隐式转换？避免参数误传编译通过

先看你给出的代码示例：

void foo(int bar, bool stuff)
{
}

enum class Mode
{ 
  SomeMode_1,  SomeMode_2,
};

void foo2(int bar, Mode stuff)
{
}

int main()
{
  foo(1, true);              // (1) 按预期编译
  foo(true, 2);              // (2) 按预期编译，但不符合需求
  foo2(1, Mode::SomeMode_1); // (3) 按预期编译

  foo2(1, 1);                // (4) 按预期不编译
  foo(1, Mode::SomeMode_1);  // (5) 按预期不编译
  foo(Mode::SomeMode_1, 1);  // (6) 按预期不编译
}

案例(2)的问题在于bool和int之间的隐式转换允许参数顺序写反后依然编译通过，这种逻辑错误很难排查。下面是几种可行的解决办法：

1. 用enum class替代bool（最推荐） #

这是最直接的类型安全方案，和你代码里的Mode用法统一，能彻底杜绝隐式转换问题。定义一个仅包含true/false枚举值的强类型枚举：

enum class BoolFlag : bool
{
    False = false,
    True = true
};

void foo(int bar, BoolFlag stuff)
{
}

调用时必须显式传入BoolFlag::True或BoolFlag::False，foo(true, 2)会因为类型不匹配直接编译失败，从根源上避免参数顺序错误。

2. 删除错误参数组合的重载 #

如果不想修改原函数的参数类型，可以添加一个删除的重载，专门拦截参数顺序写反的情况：

void foo(int bar, bool stuff)
{
}

// 拦截bool在前、int在后的调用，直接编译报错
void foo(bool, int) = delete;

这样当有人写出foo(true, 2)时，编译器会优先匹配这个删除的重载，直接抛出编译错误。缺点是只能针对特定的错误组合，如果有其他隐式转换场景（比如long转bool），需要额外添加删除的重载，不如强类型方案彻底。

3. 自定义强类型bool类 #

如果需要对bool类型做扩展（比如添加成员函数），可以自定义一个禁止隐式转换的强类型bool：

struct StrongBool
{
    bool value;
    // 显式构造，禁止隐式转换
    explicit StrongBool(bool v) : value(v) {}
    // 按需添加显式的bool转换，避免隐式转换
    explicit operator bool() const { return value; }
};

void foo(int bar, StrongBool stuff)
{
}

调用时必须显式构造：foo(1, StrongBool(true))，foo(true, 2)会因为无法将int隐式转为StrongBool而报错。这个写法比enum class繁琐，适合需要扩展功能的场景。

内容的提问来源于stack exchange，提问作者Jabberwocky