Member Variable Zugriff in verschachtelten Klassen??

BorisDieKlinge

ok wie würde man das am besten lösen?? wenn ich divere klassen grouppieren will...??

und wie kann ich das lösen das dise unterklasssen auf ein allgeimesn objekt zugreifen ohen das diese global ist??

1.) Nur wenn i und j static sind.
2.) Nur wenn die Methoden static sind.
Beispiel:

#include <iostream>
using namespace std;

class foo
{
public:
    class bar
    {
    public:
        bar()
        {
            cout << i << "\n";
            sayHello();
        }
    };

private:
    static int i;
    static void sayHello()
    {
        cout << "Hello\n";
    }
};
int foo::i = 12;

int main()
{
    foo::bar fb;
}

CStoll

Du könntest den Unterklassen eine Referenz auf ein Oberklassenobjekt mitgeben - dann haben sie ihre Instanz, mit der sie arbeiten können.

(Ansonsten: Wozu brauchst du das? Evt gibt es ja eine elegantere Lösung)

BorisDieKlinge

naja ich hab quasie ne Systemklasse, welche die verschieden Modul Klassen die zusammen das system ergeben zusammenfassen soll.. deswegen hätt ich gern so ne grouppierung.. mach mal ein beispeil CStoll!!

CStoll

Nur grob skizziert:

class System
{
public:
  class Modul1
  {
    System& m_sys;
  public:
    Modul1(System& sys) : m_sys(sys) {...}
    void print(string data)
    {
      m_sys.printer.print(data);
    }
  };
  friend class Modul1;

  ...

private:
  Printer printer;//Variable des Systems
  ...
};

PS: Wenn du nur EIN System hast, kannst du auch das Singleton-Pattern verwenden, um an deine Instanz ranzukommen.

BorisDieKlinge

kann ich nun über ein System Objekt auch auf die funktionen der interen modulklassen zugreifen??

wieso hast du das modul als friend deklariert?

Wenn du auf einem Objekt arbeiten möchtest, brauchst du auch Zugriff auf ein solches. Wenn du also mit einem System-Objekt auf die Methoden eines Modul-Objekts zugreifen willst, muss das System entweder ein Modul-Objekt über seine zugreifende Methode als Parameter bekommen, oder der Zugriff muss über eine übergeordnete Variable gewährt sein. Falls es zu jedem Zeitpunkt immer nur ein System-Objekt geben soll, kann man für den Zugriff auf das System das Singleton-Entwurfsmuster anwenden.
Beispiel:

#include <iostream>
using namespace std;

class system
{
public:
    static system &exemplar()
    {
        static system dasSystem;
        return dasSystem;
    }

    class modul1
    {
    public:
        void test()
        {
            system::exemplar().sayHello();
        }
    };

    template<typename TModul>
    void testModul(TModul &m)
    {
        m.test();
    }

    void testModul2()
    {
        m2.test();
    }

private:
    //Default- und Copy-Konstruktor privatisieren,
    //um die Erstellung von System-Objekten einzuschränken
    system(){}
    system(const system &sys){}

    void sayHello()
    {
        cout << "Hello\n";
    }

    class modul2
    {
    public:
        void test()
        {
            cout << "Hier spricht modul2\n";
        }
    };

    modul2 m2;
};

int main()
{
    system::modul1 m1;
    m1.test();
    system::exemplar().testModul(m1);
    system::exemplar().testModul2();
}

CStoll

BorisDieKlinge schrieb:

kann ich nun über ein System Objekt auch auf die funktionen der interen modulklassen zugreifen??

Klar, wenn du ein Element der entsprechenden Modulklasse im System anlegst (z.B. könnte die Klasse 'Printer' im obigen Beispiel auch ein Modul sein).

wieso hast du das modul als friend deklariert?

Damit es auf die privaten Elemente des Systems zugreifen kann.

CStoll schrieb:

Damit es auf die privaten Elemente des Systems zugreifen kann.

Das kann es sowieso, weil es eine interne Klasse ist.

MFK

schorsch code schrieb:

Das kann es sowieso, weil es eine interne Klasse ist.

WMKAHEMDFH

MFK schrieb:

WMKAHEMDFH

Also KEINE Ahnung finde ich übertrieben. Immerhin habe ich es sowohl mit g++ (sogar mit -pedantic Option) als auch mit VC++2005 ausprobiert. Ok, vielleicht ist es trotzdem nur eine Compiler-Eigenheit, welche die beiden Compiler gemeinsam haben; hab den Standard leider nicht zur Hand.

MFK

Mein Fehler, hatte die innere und äußere Klasse vertauscht.

schorsch code schrieb:

Also KEINE Ahnung finde ich übertrieben.

Ich auch. Deswegen war ja auch ein Ironie-Smily dran. Bitte nicht so ernst nehmen

Simon2

BorisDieKlinge schrieb:

naja ich hab quasie ne Systemklasse, welche die verschieden Modul Klassen die zusammen das system ergeben zusammenfassen soll.. deswegen hätt ich gern so ne grouppierung.. mach mal ein beispeil CStoll!!

Hi,

also mal ganz abseits des bisherigen Trends: Das klingt für mich eher nach einem namespace als nach einer Klasse.
Ich frage mich, ob das nicht eher eine Lösung für Dein Problem wäre. Innerhalb des Namespaces könntest Du ebenfalls lustig Konstanten, Objekte&Co ablegen, die von allen Klassen sichtbar sind (ebenso "globale Objekte" in einem anonymen namespace)....

Denk' das doch mal durch...

Gruß,

Simon2.

BorisDieKlinge

hmm simon2... das hört sich gar nich so schlecht an, aller dings weis ich nicht wie da mit namespaces funktiniert!!

akari

Hallo

Siehe zum Beispiel hier.

bis bald
akari

Simon2

BorisDieKlinge schrieb:

hmm simon2... das hört sich gar nich so schlecht an, aller dings weis ich nicht wie da mit namespaces funktiniert!!

Naja, ich weiß nicht wirklich, ws Du genau vorhast, aber "Bündeln" kann man in namespaces prima:

namespace Group{

    namespace { 
        // anonymer namespace sorgt dafür, dass die außerhalb 
        // des namespaces&Moduls nicht zu sehen sind
        int internesZeug;
    }

    namespace Constants {
        const int MeineKonstante;
    }

    class A {  
    public:
        static void funktion() { internesZeug++; }
    };
    class B{
    public:
        static void funktion() {internesZeug--; }
    };

    // eigentlich brauchst Du nichtmal eine Klasse:
    namespace lustigeToolFunktionen {
        void f1() { internesZeug = 0; }
    }

    funktion() {
        B::funktion(); 
        A::funktion();
        internesZeug *= Constants::MeineKonstante; // kannst auch direkt nutzen
    }
}

using Group::B::funktion;

int main() {
    Group::lustigeToolFunktionen::f1();
    Group::funktion();
    Group::A::funktion();
    funktion(); // ruft Group::B::funktion() auf
    return 0;
}

Nur mal ein wenig "rumgefuddelt" mit namespaces und Klassen.
Wichtig: Möglichst nur dann eine Klasse bauen, wenn es sie wirklich Objekte beschreiben soll !
(so gesehen sind meine obigen A und B "schlechte Klassen")

Gruß,

Simon2.

BorisDieKlinge

hmm ja das ist das problem .. meine module werden nur einmal erzeugt, und fassen eigentlich diverse funktionen und parameter zusammen...

was ist denn eleganter namespaces oder singelton patterns??

BorisDieKlinge

dan würdest du statt der klassen A und B die wieder rum in ein namespace verpacken?

Simon2

BorisDieKlinge schrieb:

hmm ja das ist das problem .. meine module werden nur einmal erzeugt, und fassen eigentlich diverse funktionen und parameter zusammen...

was ist denn eleganter namespaces oder singelton patterns??

Das sind eigentlich keine Alternativen ... es geht eigentlich um die Frage "Globale Variable oder Singleton"; beide kannst Du sowohl in namespaces organisieren (was ich für schlau hielte)als auch ohne.
Ob sich ein singleton lohnt, mag ich nicht beurteilen, aber es gibt zum Thema "Globale Variablen vs Singleton" schon Einiges in diesem Forum zu finden.

Gruß,

Simon2.