我最初发布了一个如何使用一些隐式转换技巧实现这一点的例子，但意识到这可以进一步简化。
我假设你写了你想传递Code类型的方法;最简单的选择是添加一个简单的重载，它也接受Code，执行转换为std::string，然后将结果传递给另一个方法，例如。

void work(std::string);

/* adding.... */
void work(Code c)
{
  switch (c)
  {
    case Code::A: return work("A");
    case Code::B: return work("B");
    case Code::C: return work("C");
    default: __builtin_unreachable();
  }
}

字符串
如果该方法是标准库的一部分，我相信在这里添加您自己的重载将是UB，但是您可以在新的名称空间中引入它，并使用ADL来解决其余问题。
最好的答案最终取决于你所处的确切情况，但这可能是一个很好的起点。

我不知道你为什么需要这个，所以我的建议可能有点离谱。但是如果你需要一个可以被视为Code或字符串的值，那么我们可以创建一个 Package 器类，它将转换为以下任何一种：

struct Code_class
{
    Code c;

    Code_class(Code c) : c{c} {}

    operator Code() const
    {
        return c;
    }

#define X(x) case Code::x: return #x
    operator std::string() const
    {
        switch (c) {
            X(A);
            X(B);
            X(C);
        }
        std::unreachable();
    }
#undef X
};

字符串

完整demo

#include <cstdint>
#include <string>
#include <utility>

enum class Code : uint8_t
{
    A = 0,
    B = 1,
    C = 2
};

struct Code_class
{
    Code c;

    /* implicit */ Code_class(Code c) : c{c} {}

    operator Code() const
    {
        return c;
    }

#define X(x) case Code::x: return #x
    operator std::string() const
    {
        switch (c) {
            X(A);
            X(B);
            X(C);
        }
        std::unreachable();
    }
#undef X
};

#include <iostream>
int main()
{
    auto m = Code::A;

    Code_class p = m;
    const std::string s = p;

    std::cout << s << '\n';
}

型

char是一种整数，所以我们可以声明char的枚举。

#include <iostream>

enum struct Cnum : char { h = 'h', o = 'o', e = 'e', l = 'l' , num_0 = '0' };

std::ostream& operator<<(std::ostream& os, Cnum c) {
    os << static_cast<char>(c);
    return os;
}

int main() {
    std::cout << Cnum::h << Cnum::e << Cnum::l << Cnum::l << Cnum::o << Cnum::num_0 << "\n";//print hello0
}

字符串
然后你可以在以后从char中构建string。