enum in zwei Klassen gleich benutzbar, wie?

THX 1138

@joomoo
Was spricht den eigentlich dagegen, den Scope anzugeben?

Muffin888

warum?

.filmor

Probier mal den Code aus, den dragon da gepostet hat ...
BTW, es ist schon ziemlicher Quatsch, ein 3 Zeichen langes A:: durch zwei böse Codezeilen zu ersetzen ...

/edit:
Vielleicht ja so:

struct B
{
    typedef A::EType EType;
// ...

Immerhin kommts ohne Präprozessor aus und ist nicht so fehleranfällig (man denke nur an ein leicht vergessenes #undef ..)

joomoo

Jo stimmt, das mit dem typedef ist der gute Weg. Schade das es nicht mit dem using geklappt hat, denn jetzt muss man zwar nicht mehr A::EType schreiben aber dafür A::First

mfg.

Michael E.

Wie wärs hiermit?

struct A
{
    enum EType { First };
};

struct B
{
    B()
    {
        struct EType : public A
        {
            EType()
            {
                elem = new A::EType();
            }

            ~EType()
            {
                delete elem;
            }

            A::EType &operator()()
            {
                return *elem;
            }

        private:
            A::EType *elem;
        } x;

        x() = EType::First;
    }
};

:p

Artchi

Ihr spinnt doch alle!

.filmor

Direkt wieder rummaulen, dass hamma gern. Er hat nur die Aufgabenstellung gelöst ;). Und selbst diese "Lösung" ist noch akzeptabler als der #define Quatsch.

joomoo

.filmor schrieb:

Er hat nur die Aufgabenstellung gelöst ;). Und selbst diese "Lösung" ist noch akzeptabler als der #define Quatsch.

Naja, eigentlich will ich ja nicht von A ableiten... Und diese Lösung finde ich viel schlimmer als das mit dem #define und sie funktioniert auch nicht besser als z.B. das mit dem typedef.

mfg.

.filmor

.filmor schrieb:

selbst diese "Lösung"

Noch Fragen?

joomoo

.filmor schrieb:

.filmor schrieb:

.filmor schrieb:

selbst diese "Lösung"

Noch Fragen?

Ne Hab's nicht gemerkt

mfg.

Michael E.

joomoo schrieb:

Naja, eigentlich will ich ja nicht von A ableiten...

Der Trick ist, dass nur die lokale Klasse von A ableitet, B aber nicht

joomoo

Michael E. schrieb:

joomoo schrieb:

Naja, eigentlich will ich ja nicht von A ableiten...

Der Trick ist, dass nur die lokale Klasse von A ableitet, B aber nicht

dadurch würden ja aber trotzdem eventuelle Member von A erstellt oder?

mfg.

Und es wurde eine reine Compile-Time Angelegenheit in eine Laufzeitangelegenheit umgewandelt, find ich nicht wirklich akzeptabel.
Das typedef löst das Problem mit dem Scope auch nur zu Hälfte und dabei die kleinere Hälfte.

Ich würd einfach den Scope mitangeben, da mir die Zeit zu schade wäre mir über sowas Gedanken zu machen.

Michael E.

joomoo schrieb:

dadurch würden ja aber trotzdem eventuelle Member von A erstellt oder?

Das stimmt. Leider kann man dieses Problem auch nicht durch ein statisches Member lösen, weil lokale Klassen sowas nicht haben dürfen.

Alles in allem sind alle Lösungen Kappes.

Vellas

Hi!

Das was du willst geht mit using, aber auch nur über Vererbung:

struct A
{
    enum EType { First };
};

struct B : public A {
	using A::EType;

    B()
    {
        EType x = First;
    }
};

Statt public kannst du auch privat erben. Durch diese using-Deklaration wird jedes benannte Member aus der Basisklasse in den Gültigkeitsbereich der abgeleiteten Klasse eingeführt. (Habe es probehalber nochmal mit VS 2005 Std. compiliert.)

Sämtliche Alternativlösungen (zu meiner Define-Lösung) sind entweder unvollständig, misachten Design-Prinzipien oder fressen Laufzeit für eine rein stilistische Angelegenheit.
Gesteht es ein für so etwas ist ein Define noch die beste Lösung. Das Problem ist ja kein richtiges Problem sondern nur eine rein stilistische Angelegenheit.

joomoo

dragon90# schrieb:

Sämtliche Alternativlösungen (zu meiner Define-Lösung) sind entweder unvollständig, misachten Design-Prinzipien oder fressen Laufzeit für eine rein stilistische Angelegenheit.
Gesteht es ein für so etwas ist ein Define noch die beste Lösung. Das Problem ist ja kein richtiges Problem sondern nur eine rein stilistische Angelegenheit.

Wieso? Das mit dem typedef ist doch besser?!

mfg.

DEvent

Jo stimmt, das mit dem typedef ist der gute Weg. Schade das es nicht mit dem using geklappt hat, denn jetzt muss man zwar nicht mehr A::EType schreiben aber dafür A::First

Übrehaupt ist doch der Sinn eines enum das man einen scope hat.

enum Fooo { xxxxx }; // einmal Fooo::xxxxx

enum Baar { xxxxx }; // einmal Baar::xxxxx

sonst kann man doch gleich statische Konstanten benutzen.
Soll heisen: Es ist ein feature, kein bug

joomoo schrieb:

dragon90# schrieb:

Sämtliche Alternativlösungen (zu meiner Define-Lösung) sind entweder unvollständig, misachten Design-Prinzipien oder fressen Laufzeit für eine rein stilistische Angelegenheit.
Gesteht es ein für so etwas ist ein Define noch die beste Lösung. Das Problem ist ja kein richtiges Problem sondern nur eine rein stilistische Angelegenheit.

Wieso? Das mit dem typedef ist doch besser?!

mfg.

Nicht wirklich:

//Deklaration
EType myEnum = A::First;

if( myEnum == A::First )
    myEnum = A::Second;
//...

Man spart den Scope nur bei der Deklaration ein, aber gerade da ist es ja egal, das muss man ja nur einmal pro Variable machen.

.filmor

Jaha, das bekommt deine Variante aber auch nicht hin. Warum das typedef besser als der Präprozessor ist hab ich schon einmal geschrieben.
Und jetzt ist mal bitte Ruhe hier... :p