強く型付けされた列挙型を自動的にintに変換する方法は？

#include <iostream>

struct a {
  enum LOCAL_A { A1, A2 };
};
enum class b { B1, B2 };

int foo(int input) { return input; }

int main(void) {
  std::cout << foo(a::A1) << std::endl;
  std::cout << foo(static_cast<int>(b::B2)) << std::endl;
}

の a::LOCAL_Aは、強く型付けされた列挙型が達成しようとしていることですが、小さな違いがあります。通常の列挙型は整数型に変換できますが、強く型付けされた列挙型はキャストなしでは変換できません。

それで、強く型付けされた列挙値をキャストなしで整数型に変換する方法はありますか？はいの場合、どのように？

あなたの質問で述べたようにスコープの問題だけでなく、複数の問題を解決することを目的とした強く型付けされた列挙型：

1. 型の安全性を提供し、整数の昇格による整数への暗黙の変換を排除します。
2. 基になるタイプを指定します。
3. 強力なスコープを提供します。

したがって、強く型付けされた列挙型を暗黙的に整数に変換したり、その基礎となる型に変換したりすることは不可能です。したがってstatic_cast、変換を明示的にするために使用する必要があります。

唯一の問題がスコープであり、整数への暗黙的な昇格が本当に必要な場合は、強く型付けされていない列挙型を、それが宣言されている構造体のスコープで使用することをお勧めします。

他の人が言ったように、暗黙の変換を行うことはできません。これは仕様によるものです。

必要な場合は、キャストで基になる型を指定する必要を回避できます。

template <typename E>
constexpr typename std::underlying_type<E>::type to_underlying(E e) noexcept {
    return static_cast<typename std::underlying_type<E>::type>(e);
}

std::cout << foo(to_underlying(b::B2)) << std::endl;

R. Martinho Fernandesによって提供された回答のC ++ 14バージョンは次のようになります。

#include <type_traits>

template <typename E>
constexpr auto to_underlying(E e) noexcept
{
    return static_cast<std::underlying_type_t<E>>(e);
}

前の回答と同様に、これはあらゆる種類の列挙型と基になる型で機能します。noexcept例外をスローしないため、キーワードを追加しました。

アップデート
これは、Scott MeyersによるEffective Modern C ++にも表示されます。項目10を参照してください（これは、私の本のコピー内の項目の最後のページで詳しく説明されています）。

#include <cstdlib>
#include <cstdio>
#include <cstdint>

#include <type_traits>

namespace utils
{

namespace details
{

template< typename E >
using enable_enum_t = typename std::enable_if< std::is_enum<E>::value, 
                                               typename std::underlying_type<E>::type 
                                             >::type;

}   // namespace details


template< typename E >
constexpr inline details::enable_enum_t<E> underlying_value( E e )noexcept
{
    return static_cast< typename std::underlying_type<E>::type >( e );
}   


template< typename E , typename T>
constexpr inline typename std::enable_if< std::is_enum<E>::value &&
                                          std::is_integral<T>::value, E
                                         >::type 
 to_enum( T value ) noexcept 
 {
     return static_cast<E>( value );
 }

} // namespace utils




int main()
{
    enum class E{ a = 1, b = 3, c = 5 };

    constexpr auto a = utils::underlying_value(E::a);
    constexpr E    b = utils::to_enum<E>(5);
    constexpr auto bv = utils::underlying_value(b);

    printf("a = %d, b = %d", a,bv);
    return 0;
}

いいえ、自然な方法はありません。

実際、enum classC ++ 11で強く型付けされた動機の1つは、C ++ 11へのサイレント変換を防ぐことintです。

暗黙の変換（設計上）がない理由は、他の回答で説明されています。

個人的にはoperator+、列挙型クラスからその基になる型への変換に単項を使用しています。

template <typename T>
constexpr auto operator+(T e) noexcept
    -> std::enable_if_t<std::is_enum<T>::value, std::underlying_type_t<T>>
{
    return static_cast<std::underlying_type_t<T>>(e);
}

「タイピングのオーバーヘッド」はほとんどありません。

std::cout << foo(+b::B2) << std::endl;

マクロを実際に使用して列挙型と演算子関数を1つのショットで作成する場合。

#define UNSIGNED_ENUM_CLASS(name, ...) enum class name : unsigned { __VA_ARGS__ };\
inline constexpr unsigned operator+ (name const val) { return static_cast<unsigned>(val); }

これがあなたや誰かを助けることを願っています

enum class EnumClass : int //set size for enum
{
    Zero, One, Two, Three, Four
};

union Union //This will allow us to convert
{
    EnumClass ec;
    int i;
};

int main()
{
using namespace std;

//convert from strongly typed enum to int

Union un2;
un2.ec = EnumClass::Three;

cout << "un2.i = " << un2.i << endl;

//convert from int to strongly typed enum
Union un;
un.i = 0; 

if(un.ec == EnumClass::Zero) cout << "True" << endl;

return 0;
}

上記の投稿が指摘するように、短い答えはあなたがすることはできません。しかし、私の場合、名前空間を乱雑にしたくなかっただけで、暗黙の変換がまだ残っているので、次のようにしました。

#include <iostream>

using namespace std;

namespace Foo {
   enum Foo { bar, baz };
}

int main() {
   cout << Foo::bar << endl; // 0
   cout << Foo::baz << endl; // 1
   return 0;
}

名前空間の一種は、タイプセーフのレイヤーを追加しますが、列挙型の値を基になる型に静的にキャストする必要はありません。

これは、ネイティブで不可能だenum classが、おそらくあなたはモックができenum classてclass：

この場合、

enum class b
{
    B1,
    B2
};

以下と同等になります：

class b {
 private:
  int underlying;
 public:
  static constexpr int B1 = 0;
  static constexpr int B2 = 1;
  b(int v) : underlying(v) {}
  operator int() {
      return underlying;
  }
};

これはほとんどオリジナルと同等enum classです。b::B1戻り値の型を持つ関数で直接forに戻ることができbます。できるよswitch case等で。

そして、この例の精神では、テンプレートを（おそらく他のものと一緒に）使用して、enum class構文で定義されたすべての可能なオブジェクトを一般化およびモックすることができます。

多くの人が言ったように、オーバーヘッドと複雑さを追加せずに自動的に変換する方法はありませんが、いくつかのキャストがシナリオで少し使用される場合は、入力を少し減らし、ラムダを使用して見栄えをよくすることができます。これにより、関数のオーバーヘッド呼び出しが少し追加されますが、以下に示すように、長いstatic_cast文字列に比べてコードが読みやすくなります。これはプロジェクト全体では役に立ちませんが、クラス全体でのみ役立ちます。

#include <bitset>
#include <vector>

enum class Flags { ......, Total };
std::bitset<static_cast<unsigned int>(Total)> MaskVar;
std::vector<Flags> NewFlags;

-----------
auto scui = [](Flags a){return static_cast<unsigned int>(a); };

for (auto const& it : NewFlags)
{
    switch (it)
    {
    case Flags::Horizontal:
        MaskVar.set(scui(Flags::Horizontal));
        MaskVar.reset(scui(Flags::Vertical)); break;
    case Flags::Vertical:
        MaskVar.set(scui(Flags::Vertical));
        MaskVar.reset(scui(Flags::Horizontal)); break;

   case Flags::LongText:
        MaskVar.set(scui(Flags::LongText));
        MaskVar.reset(scui(Flags::ShorTText)); break;
    case Flags::ShorTText:
        MaskVar.set(scui(Flags::ShorTText));
        MaskVar.reset(scui(Flags::LongText)); break;

    case Flags::ShowHeading:
        MaskVar.set(scui(Flags::ShowHeading));
        MaskVar.reset(scui(Flags::NoShowHeading)); break;
    case Flags::NoShowHeading:
        MaskVar.set(scui(Flags::NoShowHeading));
        MaskVar.reset(scui(Flags::ShowHeading)); break;

    default:
        break;
    }
}

C ++委員会は1歩進んで（グローバルネームスペースから列挙型のスコープを取得）、50段階後退しました（列挙型の整数への減衰はありません）。悲しいことにenum class列挙型の値が非記号的な方法で必要な場合は、単に使用できません。

最善の解決策は、それをまったく使用せず、代わりにネームスペースまたは構造体を使用して列挙型を自分でスコープすることです。この目的のために、それらは交換可能です。列挙型自体を参照するときは、少し余分に入力する必要がありますが、多くの場合はそうではありません。

struct TextureUploadFormat {
    enum Type : uint32 {
        r,
        rg,
        rgb,
        rgba,
        __count
    };
};

// must use ::Type, which is the extra typing with this method; beats all the static_cast<>()
uint32 getFormatStride(TextureUploadFormat::Type format){
    const uint32 formatStride[TextureUploadFormat::__count] = {
        1,
        2,
        3,
        4
    };
    return formatStride[format]; // decays without complaint
}