FYI, https://wg21.link/P2641 proposes

template<class T>
  consteval bool is_active_member(T* p);

3
Returns: true if p is a pointer to the active member of a union or a subobject thereof; otherwise, false.

4
Remarks: A call to this function is not a core constant expression ([expr.const]) unless p is a pointer to a variant member of a union or a subobject thereof.

5
[Example 2:

struct OptBool {
  union { bool b; char c; };

  constexpr OptBool() : c(2) { }
  constexpr OptBool(bool b) : b(b) { }

  constexpr auto has_value() const -> bool {
    if consteval {
      return std::is_active_member(&b);   // during constant evaluation, cannot read from c
    } else {
      return c != 2;                      // during runtime, must read from c
    }
  }

  constexpr auto operator*() -> bool& {
    return b;
  }
};

constexpr OptBool disengaged;
constexpr OptBool engaged(true);
static_assert(!disengaged.has_value());
static_assert(engaged.has_value());
static_assert(*engaged);

end example]

And it can be simulated with some amount of success: https://gcc.godbolt.org/z/q6oWzn45K.

  // Simulate `std::is_active_member` (P2641). This works with Clang and GCC for our use case.
  template<class T> [[nodiscard]] constexpr bool is_held_alternative(const T& x) noexcept {
    if constexpr (variant<T>)
      return std::apply([&](auto... ap) { return (... or is_held_alternative(x.*ap)); }, T::alternative_pointers);
    else if constexpr (std::is_same_v<T, std::intmax_t>) return __builtin_constant_p(x);
    else if constexpr (std::is_array_v<T>) return is_held_alternative(x[0]);
    else if constexpr (requires { x->symbol; }) return __builtin_constant_p(x->symbol);
    else if constexpr (std::is_pointer_v<T>) return __builtin_constant_p(*x);
    else return std::apply([](auto&... m) { return (... and is_held_alternative(m)); }, structure_tie(x));
  }

  template<class A, class V> requires alternative_for<A, V>
  [[nodiscard]] constexpr bool holds_alternative(V& v) noexcept {
    return is_held_alternative(v.*get<A V::*>(V::alternative_pointers));
  }

Uh oh!

Things you don't know about C++ Unions #93

Description

Metadata

Metadata

Assignees

Labels

Projects

Milestone

Relationships

Development

Issue actions