enum class TestE
{
   a,
   b
};

unsigned int operator* (TestE x)
{
   return TestE::a == x ? 0 : 1;
};


   TestE asdf = TestE::b;

   unsigned int v = *asdf;
   unsigned int vv = *TestE::b;

enum Enum {
    Foo
};

void fn(Enum);
void fn(int);

void test() {
    fn(Foo);   // вызов перегрузки  void fn(Enum)
    fn(+Foo);  // вызов перегрузки  void fn(int)
}

return static_cast<std::underlying_type_t<TestE>>(x);

w> Достаточно неожиданно встретить перегрузку operator*, когда все для этих целей перегружают унарный operator+

 void test() {
     fn(Foo);   // вызов перегрузки  void fn(Enum)
     fn(toInt(Foo));  // вызов перегрузки  void fn(int)
 }

enum class UserId{};
UserId id;
std::cout << "User id: " << utl::cast(id);

#include <iostream>
#include <chrono>

class A
{
public:
  static const unsigned TIMEOUT = 300;
};


void foo(std::chrono::milliseconds timeout)
{
}


void boo()
{
  foo( std::chrono::milliseconds(A::TIMEOUT) );
  //foo( std::chrono::milliseconds(+A::TIMEOUT) ); //OK
}


int main()
{
    std::cout << "the end\n";
    return 0;
}

auto en = AsEnum<SomeEnumeName>(x);

#define Convert_EnumValue_To_Integer(x) ((int)x)

RW>#define Convert_EnumValue_To_Integer(x) ((int)x)
RW>

float foo()
{
  return 1.1f;
}

auto x = Convert_EnumValue_To_Integer(a + foo());

BFE>>auto en = AsEnum<SomeEnumeName>(x);
BFE>>

auto enum_x = toEnum<1_x -> SomeEnumeName::one, 2_x -> SomeEnumeName::two, default_x -> []{ return SomeEnumeName::undefined; }>(x);

namespace std {
enum class byte : unsigned char {};
...

enum class Color : std::uint32_t
{
  red   = 0xFF0000,
  green = 0x00FF00,
  blue  = 0x0000FF
};

assert(asOrdinal(Color::red  ) == 0);
assert(asOrdinal(Color::green) == 1);
assert(asOrdinal(Color::blue ) == 2);

assert(asValue(Color::red  ) == 0xFF0000);
assert(asValue(Color::green) == 0x00FF00);
assert(asValue(Color::blue ) == 0x0000FF);

auto foo() {
    auto lambda = [](auto i) { std::cout << i; };
    lambda(5);

    return 5;
}

auto foo() {
    struct Lambda {
        template<typename T>
        void operator()(T); // внутри функции так нельзя
    };
    Lambda{}(5);
    return 5
}