class Group{

  int i,j;

  class A{

    funktion(){ i++; }
  }
  class B{

    funktion() {j--; }
  }

  funktion(){
   B:funktion();
   A:funktion();
  }

};

1. kann ich in den untergeordneten Klassen mit i und j arbeiten?
2. kann ich auf funktionen der Klassen zugreifen ohne ein objekt der Klasse
zu erzeugen??

Durch Verschachteln der Klassen beeinflusst du nur die Namensauflösung und die Zugriffsrechte. Damit werden keine Instanzen aneinander gebunden. Und ohne Instanzen keine Member.

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

#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;
}

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

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.

wieso hast du das modul als friend deklariert?

#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();
}

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.

Damit es auf die privaten Elemente des Systems zugreifen kann.

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

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

WMKAHEMDFH

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.

schorsch code schrieb:

Also KEINE Ahnung finde ich übertrieben.

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

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.

Siehe zum Beispiel hier.

bis bald
akari

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.

was ist denn eleganter namespaces oder singelton patterns??

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.