创建类似 constexpr 枚举的类型

Question

我一直使用enum class FooEnabled : bool { no, yes }; 作为创建类型安全bools 的一种方式。它工作得很好，除了我想添加对bool 的显式转换、operator! 等布尔运算符等。我可以这样做：

template <typename Tag>
class TypedBool {
    bool value;
    explicit constexpr TypedBool(bool b) noexcept : value(b) {}
public:
    static inline TypedBool no{false};
    static inline TypedBool yes{true};
    
    explicit constexpr operator bool() const noexcept { return value; }
    constexpr TypedBool operator!() const noexcept { return TypedBool{!value}; }
    // ...
};

using FooEnabled = TypedBool<struct FooEnabledTag>;

这很好用，但是 no 和 yes 不是 constexpr，所以我不能做 if constexpr (FooEnabled::yes) { 的例子。如果我将no 和yes 改为static constexpr，clang 会感到不安，因为TypedBool 不是文字类型。这似乎是因为 TypedBool 在那个时候是不完整的。

最简单的例子是struct S { static constexpr S s; };，它给出了

error: constexpr variable cannot have non-literal type 'const S'
struct S { static constexpr S s; };
                              ^
note: incomplete type 'const S' is not a literal type
note: definition of 'S' is not complete until the closing '}'
struct S { static constexpr S s; };

有没有办法解决这个问题？我可以让no 和yes 成为隐式转换为TypedBool<Tag> 的不同类型，但这看起来很奇怪，因为那样auto x = FooEnabled::yes; 会使x 不是FooEnabled，所以

auto x = FooEnabled::yes;
[](FooEnabled& x) { x = !x; }(x);

会失败。

有没有办法让一个类包含属于它自己类型的static constexpr 成员？我开始想到的解决方案似乎都太丑陋了（而且这些解决方案也有constexpr 的限制）。

Answer 1

我认为您可以在不更改范围枚举的情况下实现您的目标（支持 ! 运算符和显式转换为布尔值）。

所有作用域枚举似乎都支持显式转换为 bool，即使 bool 不是基础类型

enum class NotBool : int { No, Yes };
constexpr bool bad = NotBool::Yes; // compile error
constexpr bool yes = bool(NotBool::Yes);

您可以为所有范围内的枚举重载 ! 运算符，这些枚举具有带有模板和 std::enable_if 的基础布尔值：

template <typename T>
constexpr bool HasUnderlyingBool = std::is_same_v<std::underlying_type_t<T>, bool>;

template <typename T>
constexpr std::enable_if_t<HasUnderlyingBool<T>, T> operator !(const T& value) {
    return T(!bool(value));
}

enum class Bool : bool { No, Yes };
static_assert(!Bool::Yes == Bool::No);
static_assert(!Bool::No == Bool::Yes);

Answer 2

有没有办法让一个类包含属于它自己类型的静态 constexpr 成员？

是的，有，只是将声明和定义分开，只有定义需要包含constexpr。

struct Foo {
    constexpr Foo(bool b): value(b){}

    static const Foo yes;
    static const Foo no;

    constexpr explicit operator bool() const noexcept{return value;}
    bool value;
};
// Mark inline if in a header.
inline constexpr const Foo Foo::yes{true};
inline constexpr const Foo Foo::no{false};

int main(){

    if constexpr(Foo::yes){
        return 5;
    };
}

这不是声明与定义不同吗？

所有三个编译器 g++,clang++,MSCV 19 都接受上面的代码。

但是如果Foo 是一个模板，clang++ 就不再编译代码，就像在 cmets 中发现的那样。

有一个question about this 暗示标准不禁止这样做。 不幸的是，C++17、C++20 标准也没有更明确，指出： 最终的 C++17 草案需要 [dcl.constexpr][Empahis mine]

constexpr 说明符应仅应用于变量或变量模板的定义或函数或函数模板的声明。 consteval 说明符仅应用于函数或函数模板的声明。 使用 constexpr 或 consteval 说明符声明的函数或静态数据成员隐含地是内联函数或变量 ([dcl.inline])。 如果函数或函数模板的任何声明具有 constexpr 或 consteval 说明符，则其所有声明应包含相同的说明符。

所以我认为这是允许的，但可能是由于疏忽而不是深思熟虑。我没有设法在标准中找到任何可以验证这种方法的示例。

Answer 3

这是我所知道的最接近的语法

class TypedBool 
{
public:    
    explicit constexpr TypedBool(bool value) noexcept : 
        m_value{ value }
    {
    }

    static constexpr TypedBool no()
    {
        constexpr TypedBool value{ false };
        return value;
    }
 
    static constexpr TypedBool yes()
    {
        constexpr TypedBool value{ true };
        return value;
    }

    explicit constexpr operator bool() const noexcept { return m_value; }

private:
    bool m_value;


};

int main()
{
    constexpr TypedBool value{ true };
    static_assert(value);
    static_assert(TypedBool::yes());
    return 0;
}