Wie konvertiere ich stark typisierte Enum automatisch in 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;
}

Das a::LOCAL_Aist es, was die stark typisierte Aufzählung zu erreichen versucht, aber es gibt einen kleinen Unterschied: Normale Aufzählungen können in Ganzzahlentypen konvertiert werden, während stark typisierte Aufzählungen dies nicht ohne Umwandlung tun können.

Gibt es also eine Möglichkeit, einen stark typisierten Aufzählungswert in einen ganzzahligen Typ ohne Umwandlung umzuwandeln? Wenn ja, wie?

Stark typisierte Enums, die darauf abzielen, mehrere Probleme zu lösen und nicht nur das in Ihrer Frage erwähnte Scoping-Problem:

1. Bieten Sie Typensicherheit und vermeiden Sie so die implizite Konvertierung in eine Ganzzahl durch integrale Heraufstufung.
2. Geben Sie die zugrunde liegenden Typen an.
3. Sorgen Sie für ein starkes Scoping.

Daher ist es unmöglich, eine stark typisierte Aufzählung implizit in Ganzzahlen oder sogar in den zugrunde liegenden Typ umzuwandeln - das ist die Idee. Sie müssen also verwenden static_cast, um die Konvertierung explizit zu machen.

Wenn Ihr einziges Problem das Scoping ist und Sie wirklich eine implizite Heraufstufung in Ganzzahlen wünschen, sollten Sie besser nicht stark typisierte Aufzählungen mit dem Umfang der Struktur verwenden, in der sie deklariert sind.

Wie andere gesagt haben, kann es keine implizite Konvertierung geben, und das ist beabsichtigt.

Wenn Sie möchten, können Sie vermeiden, dass der zugrunde liegende Typ in der Besetzung angegeben werden muss.

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;

Eine C ++ 14-Version der Antwort von R. Martinho Fernandes wäre:

#include <type_traits>

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

Wie bei der vorherigen Antwort funktioniert dies mit jeder Art von Aufzählung und zugrunde liegendem Typ. Ich habe das noexceptSchlüsselwort hinzugefügt, da es niemals eine Ausnahme auslösen wird.

Update
Dies erscheint auch in Effective Modern C ++ von Scott Meyers . Siehe Punkt 10 (er ist auf den letzten Seiten des Artikels in meiner Kopie des Buches aufgeführt).

#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;
}

Nein, es gibt keinen natürlichen Weg .

Tatsächlich besteht eine der Beweggründe für die starke Eingabe enum classin C ++ 11 darin, die stille Konvertierung in C ++ 11 zu verhindern int.

Der Grund für das Fehlen einer impliziten Konvertierung (beabsichtigt) wurde in anderen Antworten angegeben.

Ich persönlich verwende unary operator+für die Konvertierung von Aufzählungsklassen in den zugrunde liegenden Typ:

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);
}

Was ziemlich wenig "Tippaufwand" gibt:

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

Wo ich tatsächlich ein Makro verwende, um Enums und die Operatorfunktionen auf einmal zu erstellen.

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

Hoffe das hilft dir oder jemand anderem

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;
}

Eine kurze Antwort ist, dass Sie nicht wie oben beschrieben darauf hinweisen können. Aber für meinen Fall wollte ich den Namespace einfach nicht überladen, aber dennoch implizite Konvertierungen durchführen, also habe ich einfach Folgendes getan:

#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;
}

Die Art des Namespaces fügt eine Ebene der Typensicherheit hinzu, während ich dem zugrunde liegenden Typ keine Aufzählungswerte statisch umwandeln muss.

Dies scheint mit dem Eingeborenen unmöglich enum class, aber wahrscheinlich können Sie ein enum classmit einem verspotten class:

In diesem Fall,

enum class b
{
    B1,
    B2
};

wäre gleichbedeutend mit:

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;
  }
};

Dies entspricht größtenteils dem Original enum class. Sie können b::B1in einer Funktion mit Rückgabetyp direkt für zurückgeben b. Sie können damit machen switch case, etc.

Im Sinne dieses Beispiels können Sie Vorlagen (möglicherweise zusammen mit anderen Dingen) verwenden, um jedes mögliche Objekt, das durch die enum classSyntax definiert wird, zu verallgemeinern und zu verspotten .

Wie viele sagten, gibt es keine Möglichkeit, automatisch zu konvertieren, ohne Overhead und zu viel Komplexität hinzuzufügen, aber Sie können Ihre Eingabe ein wenig reduzieren und sie durch die Verwendung von Lambdas besser aussehen lassen, wenn einige Besetzungen in einem Szenario etwas häufig verwendet werden. Dies würde ein wenig Funktions-Overhead-Aufruf hinzufügen, aber den Code im Vergleich zu langen static_cast-Zeichenfolgen besser lesbar machen, wie unten zu sehen ist. Dies ist möglicherweise nicht projektweit nützlich, sondern nur klassenweit.

#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;
    }
}

Das C ++ - Komitee machte einen Schritt vorwärts (Aufzählung von Aufzählungen aus dem globalen Namespace) und fünfzig Schritte zurück (kein Zerfall des Aufzählungstyps in eine Ganzzahl). Leider enum classist es einfach nicht verwendbar, wenn Sie den Wert der Aufzählung auf nicht symbolische Weise benötigen.

Die beste Lösung besteht darin, es überhaupt nicht zu verwenden und stattdessen die Aufzählung selbst mithilfe eines Namespace oder einer Struktur zu erfassen. Zu diesem Zweck sind sie austauschbar. Sie müssen ein wenig mehr eingeben, wenn Sie sich auf den Aufzählungstyp selbst beziehen, aber das wird wahrscheinlich nicht oft der Fall sein.

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
}