Ich möchte das Klasse B ohne das A:: davor auf das enum aus der ersten Klasse zugreifen kann. Wie lässt sich das realisieren? (Das enum soll von außen aber per A:: erreichbar sein, also es darf nicht global sein)

mfg.

struct A
{
    enum EType { First };
};

struct B
{
    using A::EType;

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

Probier mal folgendes aus:

struct B
{
   using A::EType;
};

Weiß nicht ob es funktioniert.

Wenn du das auch nicht willst, bleibt nur die Ableitung von A. Aber das wäre wirklich dreckig, wenn es fachlich keinen Sinn macht und du nur auf das A:: verzichten willst,

@others
Das mit dem using hatte ich auch schon ausprobiert, doch klappt wie gesagt nicht.

mfg.

@dragon50#
Danke! Das mit dem define ist echt ein guter weg. Vielleicht ja auch der einzige?

Es ist kein guter Weg ...

/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 ..)

mfg.

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

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 schrieb:

selbst diese "Lösung"

Noch Fragen?

.filmor schrieb:

.filmor schrieb:

selbst diese "Lösung"

Noch Fragen?

Ne Hab's nicht gemerkt

mfg.

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

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

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.

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

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.

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.

Wieso? Das mit dem typedef ist doch besser?!

mfg.

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

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.