enum in zwei Klassen gleich benutzbar, wie?

joomoo

struct A
{
    enum EType { First };
};

struct B
{
    B()
    {
        A::EType x = A::First; // klappt
        EType x = First; // EType undeclared
    }
};

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
{
#define EType A::Etype
    B()
    {
        A::EType x = A::First; // klappt
        EType x = First; // EType undeclared
    }
#undef EType
};

Michael E.

dragon90: Das geht auch schöner.

struct A
{
    enum EType { First };
};

struct B
{
    using A::EType;

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

Artchi

Hihi, so einfach geht das nicht. A ist schliesslich ein eigener Scope, du wirst also irgendwie den Qualifizierer mit angeben müssen.

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,

Das funktioniert nicht, bleibt nur ein Define übrig und Vererbung fällt ja weg (es sei denn du hast in B eine Komposition, dann könntest ja von A privat erben).

joomoo

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

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

mfg.

.filmor

joomoo schrieb:

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

Es ist kein guter Weg ...

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.