วิธีการแปลง enum ที่พิมพ์โดยเฉพาะอย่างยิ่งเป็น 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คือสิ่งที่ enum ที่พิมพ์อย่างรุนแรงพยายามที่จะบรรลุ แต่มีความแตกต่างเล็กน้อย: enums ปกติสามารถแปลงเป็นประเภทจำนวนเต็มได้ในขณะที่ enums ที่พิมพ์อย่างรุนแรงไม่สามารถทำได้โดยไม่ต้องใช้นักแสดง

ดังนั้นมีวิธีการแปลงค่า enum ที่พิมพ์ออกมาอย่างมากเป็นประเภทจำนวนเต็มโดยไม่ต้องใช้แคสต์หรือไม่? ถ้าใช่เป็นอย่างไร

พิมพ์ enums อย่างยิ่งมุ่งหวังที่จะแก้ปัญหาหลายประการและไม่เพียง แต่ปัญหาการกำหนดขอบเขตตามที่คุณกล่าวถึงในคำถามของคุณ:

1. จัดเตรียมความปลอดภัยของประเภทจึงกำจัดการแปลงโดยนัยไปเป็นจำนวนเต็มโดยการส่งเสริมการขายที่สำคัญ
2. ระบุประเภทพื้นฐาน
3. ให้การกำหนดขอบเขตที่แข็งแกร่ง

ดังนั้นจึงเป็นไปไม่ได้ที่จะแปลงค่า enum ที่พิมพ์อย่างรุนแรงเป็นจำนวนเต็มหรือแม้กระทั่งประเภทพื้นฐาน - นั่นคือแนวคิด ดังนั้นคุณต้องใช้static_castการแปลงอย่างชัดเจน

หากปัญหาเพียงอย่างเดียวของคุณคือการกำหนดขอบเขตและคุณต้องการให้มีการโปรโมตเป็นจำนวนเต็มโดยปริยายคุณควรใช้ enum ที่ไม่พิมพ์อย่างมากโดยมีขอบเขตของโครงสร้างที่ประกาศไว้

อย่างที่คนอื่นพูดคุณไม่สามารถมีการแปลงโดยนัยและนั่นคือโดยการออกแบบ

หากคุณต้องการคุณสามารถหลีกเลี่ยงความต้องการที่จะระบุประเภทพื้นฐานในการโยน

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;

คำตอบรุ่น C ++ 14 ที่จัดทำโดยR. Martinho Fernandesจะเป็น:

#include <type_traits>

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

เช่นเดียวกับคำตอบก่อนหน้านี้จะทำงานกับประเภท enum และพื้นฐานทุกชนิด ฉันได้เพิ่มnoexceptคำหลักแล้วจะไม่มีข้อยกเว้น

การปรับปรุง
นี้ยังปรากฏอยู่ในที่มีประสิทธิภาพสมัยใหม่ 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 classใน C ++ 11 intเพื่อป้องกันไม่ให้มีการแปลงเงียบของพวกเขาไป

เหตุผลที่ไม่มีการแปลงโดยปริยาย (โดยการออกแบบ) ให้คำตอบอื่น

โดยส่วนตัวฉันใช้ unary operator+สำหรับการแปลงจากคลาส enum เป็นชนิดพื้นฐาน:

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;

ที่จริงฉันใช้มาโครเพื่อสร้าง enums และฟังก์ชั่นโอเปอเรเตอร์ในนัดเดียว

#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แต่คุณอาจเยาะเย้ย a 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สำหรับฟังก์ชันที่มีประเภทส่งคืน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 ++ ใช้เวลาหนึ่งก้าวไปข้างหน้า (กำหนดขอบเขตจากเนมสเปซส่วนกลาง) และถอยกลับห้าสิบขั้นตอน (ไม่มีการสลายประเภท enum เป็นจำนวนเต็ม) น่าเศร้าที่enum classไม่สามารถใช้งานได้ง่ายหากคุณต้องการคุณค่าของ enum ในรูปแบบที่ไม่ใช่สัญลักษณ์

ทางออกที่ดีที่สุดคือไม่ใช้เลยและให้ขอบเขตตัวเองโดยใช้เนมสเปซหรือโครงสร้างแทน สำหรับจุดประสงค์นี้พวกมันสามารถใช้แทนกันได้ คุณจะต้องพิมพ์เพิ่มอีกเล็กน้อยเมื่ออ้างถึงประเภท enum แต่อาจไม่บ่อยนัก

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
}