C/C++ enums: Erkennen, wenn mehrere Elemente anzeigen, um denselben Wert

Gibt es einen compile-Zeit-Weg zu erkennen /verhindern, dass doppelte Werte in einer C/C++ Aufzählung?

Der Haken ist, dass sind mehrere Elemente vorhanden, die initialisiert werden, um explizite Werte.

Hintergrund:

Habe ich geerbt, einige C-code wie den folgenden:

#define BASE1_VAL    (5)
#define BASE2_VAL    (7)

typedef enum
{
  MsgFoo1A = BASE1_VAL,       //5
  MsgFoo1B,                   //6
  MsgFoo1C,                   //7
  MsgFoo1D,                   //8
  MsgFoo1E,                   //9
  MsgFoo2A = BASE2_VAL,       //Uh oh!  7 again...
  MsgFoo2B                    //Uh oh!  8 again...
} FOO;

Das problem ist, dass, wie der code wächst & Entwickler fügen Sie weitere Nachrichten an die MsgFoo1x Gruppe, die schließlich es overruns BASE2_VAL.

Dieser code wird schließlich migriert werden C++, so dass, wenn es ein C++-Lösung (template-Magie?), das ist OK-aber eine Lösung, die mit C und C++ ist besser.

InformationsquelleAutor Dan | 2010-04-05

c c++enums

14

Gibt es ein paar Möglichkeiten, um dies zu überprüfen compile-Zeit, aber Sie könnten nicht immer für Sie arbeiten. Starten Sie durch einfügen von "marker" enum-Wert direkt vor MsgFoo2A.
```
typedef enum
{
    MsgFoo1A = BASE1_VAL,
    MsgFoo1B,
    MsgFoo1C,
    MsgFoo1D,
    MsgFoo1E,
    MARKER_1_DONT_USE, /* Don't use this value, but leave it here.  */
    MsgFoo2A = BASE2_VAL,
    MsgFoo2B
} FOO;
```
Nun müssen wir einen Weg finden, um sicherzustellen, dass MARKER_1_DONT_USE < BASE2_VAL zur compile-Zeit. Es gibt zwei gängige techiques.

Negative Größe arrays

Es ist ein Fehler deklarieren Sie ein array mit einer negativen Größe. Das sieht ein wenig hässlich, aber es funktioniert.
```
extern int IGNORE_ENUM_CHECK[MARKER_1_DONT_USE > BASE2_VAL ? -1 : 1];
```
Fast alle compiler, die jemals geschrieben wurden, wird ein Fehler generiert, wenn MARKER_1_DONT_USE größer ist als BASE_2_VAL. GCC spuckt:
```
test.c:16: error: size of array ‘IGNORE_ENUM_CHECK’ is negative
```
Statische assertions

Wenn Ihr compiler unterstützt C11, können Sie _Static_assert. Unterstützung für C11 ist nicht allgegenwärtig, aber der compiler kann unterstützen _Static_assert sowieso, vor allem, da die entsprechende Funktion in C++ wird allgemein unterstützt.
```
_Static_assert(MARKER_1_DONT_USE < BASE2_VAL, "Enum values overlap.");
```
GCC spuckt folgende Meldung:
```
test.c:16:1: error: static assertion failed: "Enum values overlap."
 _Static_assert(MARKER_1_DONT_USE < BASE2_VAL, "Enum values overlap.");
 ^
```
- Es nicht der Präprozessor, aber es ist ein böser hack trotzdem.
- Oops -- falsch verstanden. Ja, sehr lustig evil hack 🙂
- Alle nützlichen Antworten hier - akzeptiert dies, weil Sie arbeiten müssen, in C sowie C++ (viel FUD zu überwinden, in der Gruppe bezüglich C++ noch), und es scheint zu sein, die am ehesten verstanden werden & gefolgt von der Gruppe. (Ich habe es nicht in dem Beispiel, aber es gibt mehrere Elemente initialisiert, die innerhalb der enum - wahrscheinlich um die 15 jetzt. Jedes mal, wenn ein neuer Bereich/Gruppe wird Hinzugefügt, ein weiterer "check array" Hinzugefügt werden müssen. Jedermann mit einem Impuls sollten die Muster & fügen Sie eine neue Prüfung array für die neue Gruppe).
InformationsquelleAutor Dietrich Epp

Ich nicht sehen "hübsch" in Ihren Anforderungen, so reiche ich diese Lösung implementiert, mit dem Boost Preprocessor library.

Als eine up-front-disclaimer, ich habe nicht verwendet Steigern.Präprozessor eine ganze Menge und ich habe nur getestet, mit der Testfälle dargestellt, die hier, so könnte es sein Fehler, und es kann ein einfacher, sauberer Weg, dies zu tun. Ich begrüße Kommentare, Korrekturen, Anregungen, Beleidigungen, etc.

Hier gehen wir:

#include <boost/preprocessor.hpp>

#define EXPAND_ENUM_VALUE(r, data, i, elem)                          \
    BOOST_PP_SEQ_ELEM(0, elem)                                       \
    BOOST_PP_IIF(                                                    \
        BOOST_PP_EQUAL(BOOST_PP_SEQ_SIZE(elem), 2),                  \
        = BOOST_PP_SEQ_ELEM(1, elem),                                \
        BOOST_PP_EMPTY())                                            \
    BOOST_PP_COMMA_IF(BOOST_PP_NOT_EQUAL(data, BOOST_PP_ADD(i, 1)))

#define ADD_CASE_FOR_ENUM_VALUE(r, data, elem) \
    case BOOST_PP_SEQ_ELEM(0, elem) : break;

#define DEFINE_UNIQUE_ENUM(name, values)                                  \
enum name                                                                 \
{                                                                         \
    BOOST_PP_SEQ_FOR_EACH_I(EXPAND_ENUM_VALUE,                            \
                            BOOST_PP_SEQ_SIZE(values), values)            \
};                                                                        \
                                                                          \
namespace detail                                                          \
{                                                                         \
    void UniqueEnumSanityCheck##name()                                    \
    {                                                                     \
        switch (name())                                                   \
        {                                                                 \
            BOOST_PP_SEQ_FOR_EACH(ADD_CASE_FOR_ENUM_VALUE, name, values)  \
        }                                                                 \
    }                                                                     \
}

Dann verwenden wir es so:

DEFINE_UNIQUE_ENUM(DayOfWeek, ((Monday)    (1))
                              ((Tuesday)   (2))
                              ((Wednesday)    )
                              ((Thursday)  (4)))

Enumerator Wert ist optional; dieser code erzeugt eine Aufzählung entspricht:

enum DayOfWeek
{
    Monday = 1,
    Tuesday = 2,
    Wednesday,
    Thursday = 4
};

Erzeugt auch einen sanity-check-Funktion enthält eine switch-Anweisung wie beschrieben in Ben Voigt ' s Antwort. Wenn wir die änderung der enumeration Deklaration, so dass wir nicht eindeutige enumerator-Werte, z.B.,

DEFINE_UNIQUE_ENUM(DayOfWeek, ((Monday)    (1))
                              ((Tuesday)   (2))
                              ((Wednesday)    )
                              ((Thursday)  (1)))

wird es nicht kompilieren (Visual C++ meldet das erwartet Fehler C2196: case Wert '1' ist bereits verwendet).

Dank auch an Matthieu M., deren Antwort auf eine andere Frage hat mich interessiert, die Boost Preprocessor library.

Sieht toll aus. Vielleicht verschieben Sie den check-in einen detail namespace, um es zu halten aus dem Weg. EDIT: <3.
Gute Idee. Getan.
Nun, dass habe ich gemacht, obwohl... nicht die Boost.Präprozessor-Bibliothek mit C? (Ich würde davon ausgehen, dass es würde.) Wenn ja, vielleicht nicht mit namespace wäre besser so, es funktioniert für beide Sprachen. Öhm... ich werde darüber nachdenken, dass in den morgen.
Hm, guter Punkt. Ich bin mir ziemlich sicher Steigern.PP (nur Boost-Bibliothek) funktioniert in C. in C, ein Präfix detail_ würde gut genug funktioniert. Man könnte sogar __cplusplus zu wählen, so dass die gleiche header funktioniert auf beiden. (Generierung von verschiedenen Quellen offensichtlich.)
Woo toll 🙂 schade, dass Sie nicht finden konnten, einen besseren Weg, um den Wert festzulegen, anstatt die Einbettung einer Sequenz in einer Sequenz, ich bin sicher es gibt einen Weg, es zu tun mit einem einfachen Komma, aber ich fürchte, der erforderlich wäre, zu tun, ohne die Hilfe von Boost PP und ich habe nicht den Mut gehabt, um mich zu starten, in der es noch nicht 🙂 Als für den Schalter, kann ich schlage vor, Sie schreiben so etwas wie ein toString Methode ? Statt einer reinen compiler-guard konnten wir, nachdem alle verwenden die Methode für die eigentliche Arbeit 🙂 /me fühlt sich sehr stolz, dass meine Antwort bekam zitiert
ENUM-makro verwendet = zu definieren Initialwert.
Absolut Recht -- "Recht" nimmt durchaus in den hintergrund zu robust, zu korrigieren, und einfach zu bedienen. Und letztlich, die DEFINE_UNIQUE_ENUM () - makro verbirgt die Komplexität. Kudos.
das problem mit der Verwendung von = ist, dass Sie nicht verwenden können, die aufgezählten Werte für etwas anderes danach. In diesem Fall zum Beispiel, Sie konnten nicht die switch trick.

InformationsquelleAutor James McNellis

3

Glaube ich nicht, es ist ein Weg, um dies zu erkennen, die mit der Sprache selbst, wenn man bedenkt es gibt denkbare Fälle, wo Sie wollen würde zwei enumeration-Werte identisch sein. Sie können jedoch immer sicherzustellen, dass alle explizit set-items sind am Anfang der Liste:
```
typedef enum
{
  MsgFoo1A = BASE1_VAL,       //5
  MsgFoo2A = BASE2_VAL,       //7
  MsgFoo1B,                   //8
  MsgFoo1C,                   //9
  MsgFoo1D,                   //10
  MsgFoo1E,                   //11
  MsgFoo2B                    //12
} FOO;
```
So lange, wie Ihnen Werte zugewiesen werden, an der Spitze, keine Kollision möglich ist, es sei denn, aus irgendeinem Grund die Makros zu erweitern, um Werte, die gleich sind.

In der Regel dieses problem zu überwinden, indem eine Feste Anzahl von bits für jeden MsgFooX Gruppe, und dafür sorgen, dass jede Gruppe nicht überlaufen-es ist vorgegebenen Anzahl von bits. Die "Anzahl der bits" Lösung ist gut, denn es ermöglicht eine bitweise test zu bestimmen, bis zu welcher Nachricht der Gruppe etwas gehört. Aber es gibt keine built-in-Sprache-Funktion, um dies zu tun, denn es gibt legitime Fälle für ein enum mit zwei von der gleichen Wert:
```
typedef enum
{
    gray = 4, //Gr[ae]y should be the same
    grey = 4,
    color = 5, //Also makes sense in some cases
    couleur = 5
} FOO;
```
- Sorry, ich sollte erwähnt haben, dass die enums bleiben sollte fortlaufend sortiert, d.h. MsgFoo1B sollten identisch sein (MsgFoo1A + 1) - mein bad.
InformationsquelleAutor Billy ONeal
3

Ich kenne nichts, das automatisch überprüfen Sie alle enum-Mitglieder, aber wenn Sie wollen, um zu überprüfen, dass künftige änderungen der Initialisierungen (oder die Makros, auf die Sie sich stützen) nicht zu Kollisionen:
```
switch (0) {
    case MsgFoo1A: break;
    case MsgFoo1B: break;
    case MsgFoo1C: break;
    case MsgFoo1D: break;
    case MsgFoo1E: break;
    case MsgFoo2A: break;
    case MsgFoo2B: break;
}
```
verursacht einen compiler-Fehler, wenn eine der integralen Werte wiederverwendet wird, und die meisten Compiler auch sagen, was mit dem Wert (dem numerischen Wert) ein problem war.

InformationsquelleAutor Ben Voigt
1

Könnten Sie roll eine robustere Lösung zu definieren, enums mit Boost.Präprozessor - ob seine lohnt sich, die Zeit ist eine andere Sache.

Wenn Sie sich bewegen, um C++ sowieso, vielleicht ist die (vorgeschlagene) zu Steigern.Enum passt Sie (verfügbar über die Boost-Vault).

Ein weiterer Ansatz ist die Verwendung von so etwas wie gccxml (oder mehr bequem pygccxml) zu identifizieren, die Kandidaten für die manuelle Inspektion.
- Ich wünschte, ich könnte upvote dies (da ich upvote fast alles erwähnen boost), aber ich habe nicht verwendet diese konkrete Bibliothek vor und kann nicht 🙁 haben Sie ein Beispiel, das veranschaulicht, wie es vielleicht lösen die OP ' s problem?
- Ich meistens nur wissen, was Boost.PP kann das tun - ich hatte noch nicht Zeit, um wirklich zu kümmern. Die vorgeschlagene Erhöhung.Enum sollte ein guter Anfang sein, obwohl, mit seinem Beispiel für die Generierung der enum-definition und auch eine passende compile-time check sollte nicht allzu schwer sein.
- Macht mir klar, ich bin nicht mit Boost annähernd genug, oder zumindest nicht ansatzweise in der Nähe seiner Funktionalität - Dank.
InformationsquelleAutor Georg Fritzsche
1

Während wir nicht voll auf die Reflexion, Sie können dieses problem lösen, wenn Sie können Wiedereinstellen der enumeration-Werte.

Irgendwo in diesem wird erklärt:
```
enum E { A = 0, B = 0 };
```
anderswo, wir bauen diese Maschinen:
```
template<typename S, S s0, S... s>
struct first_not_same_as_rest : std::true_type {};
template<typename S, S s0, S s1, S... s>
struct first_not_same_as_rest : std::integral_constant< bool,
  (s0 != s1) && first_not_same_as_rest< S, s0, s... >::value
> {};


template<typename S, S... s>
struct is_distinct : std::true_type {};

template<typename S, S s0, S... s>
struct is_distinct : std::integral_constant< bool,
  std::is_distinct<S, s...>::value &&
  first_not_same_as_rest< S, s0, s... >::value
> {};
```
Sobald Sie haben, dass Maschinen (erfordert C++11), können wir Folgendes tun:
```
static_assert( is_distinct< E, A, B >::value, "duplicate values in E detected" );
```
und zur compile-Zeit werden wir sicherstellen, dass keine zwei Elemente gleich sind.

Dies erfordert O(n) Rekursionstiefe O(n^2) Arbeit durch den compiler zur compile-Zeit, also für extrem große Enumerationen, die diese Probleme verursachen könnte. Ein O(lg(n)) und Tiefe O(n lg(n)) arbeiten mit einem viel größeren Konstanten Faktor getan werden kann durch Sortieren der Liste mit Elementen, die den ersten, aber das ist viel, viel mehr Arbeit.

Mit der enum-Reflexion-code vorgeschlagen für C++1y-C++17, das wird machbar sein, ohne Wiedereinstellen Elemente.

InformationsquelleAutor Yakk - Adam Nevraumont
0

Ich nicht ganz wie die Antworten hier schon geschrieben, aber Sie Gaben mir einige Ideen. Die entscheidende Technik ist darauf zu verlassen, Ben Voight Antwort der switch-Anweisung verwenden. Wenn mehrere Fälle in einer switch-teilen sich die gleiche Zahl, erhalten Sie einen Kompilierungsfehler.

Meisten sinnvoll für mich und wahrscheinlich die original-poster, dies erfordert nicht alle C++ features.

Dinge zu bereinigen, die ich verwendet, aaronps Antwort auf Wie kann ich vermeiden, mich zu wiederholen, wenn Sie eine C++ - enum und einer abhängigen Daten Struktur?

Zunächst definieren Sie diese in ein paar header irgendwo:
```
#define DEFINE_ENUM_VALUE(name, value)      name=value,
#define CHECK_ENUM_VALUE(name, value)       case name:
#define DEFINE_ENUM(enum_name, enum_values) \
    typedef enum { enum_values(DEFINE_ENUM_VALUE) } enum_name;
#define CHECK_ENUM(enum_name, enum_values) \
    void enum_name ## _test (void) { switch(0) { enum_values(CHECK_ENUM_VALUE); } }
```
Nun, Wann immer Sie brauchen, um eine Aufzählung:
```
#define COLOR_VALUES(GEN) \
    GEN(Red, 1) \
    GEN(Green, 2) \
    GEN(Blue, 2)
```
Schließlich, diese Zeilen sind erforderlich, um tatsächlich machen die Aufzählung:
```
DEFINE_ENUM(Color, COLOR_VALUES)
CHECK_ENUM(Color, COLOR_VALUES)
```
DEFINE_ENUM macht der enum-Datentyp selbst. CHECK_ENUM macht eine test-Funktion, die schaltet alle enum-Werte. Der compiler Absturz beim kompilieren CHECK_ENUM wenn Sie Duplikate.

InformationsquelleAutor James Johnston

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.

Negative Größe arrays

Statische assertions