Kabselungsproblem

Hallo,

ich benötige eine Hauptklasse, deren Instanzen Objekte von Unterklassen beinhalten.
Die Unterklassen sollen in unterschiedlichen Quellcodemodulen definiert werden.
Zugriffs- und Namensauflösung für die Unterklassen darf aber nur in der Hauptklasse möglich sein.

Wie realisiert man so etwas mit C++ am besten?
Mit Namensbereichen, mit Vererbung?

Vielen Dank für eure Ratschläge!

Achja, feste Regeln für Präprozessor-includes sind für meine Sache nicht praktikabel.

CStoll

Geht das bitte auch auf Deutsch? Aus deiner Fragestellung werde ich noch nicht ganz schlau - also was hast du eigentlich vor?

Ich will dass eine Klasse nur innerhalb einer bestimmten Hauptklasse bekannt ist, aber in einem anderen Quellcodemodul als die Hauptklasse definiert wird.

CStoll

Widerspricht sich das nicht ein wenig?

Du kannst auch Unterklassen in einer Klassendeklaration anlegen - willst du auf so etwas hinaus?

class master
{
  class helper//nur verfügbar für 'master' und seine friend's
  {
    ...
  };
  ...
};

Simon2

Hi,

also soweit ich weiß, kannst Du die Sichtbarkeit einer Klassendeklaration nicht beschränken - anders gesagt: Wenn jemand die Headerdatei seiht, kannst Du ihn nicht hindern, ein "#include" darauf zu machen.

Allerdings kannst Du natürlich den den Zugriff durch den Compiler abweisen lassen durch private/public/friend ... aber selbst das kann natürlich durch einen hartnäckigen Nutzer um-editiert werden.

Ist das eigentlich nur ein "Geheimhaltungshobby" oder hat das einen wichtigen Hintergrund.

CStoll schrieb:

...- willst du auf so etwas hinaus?

class master
{
  class helper//nur verfügbar für 'master' und seine friend's
  {
    ...
  };
  ...
};

Naja, er wollte es ja explizit in einer sparaten Headerdatei (klar - könnte er auch per #include machen, aber ich glaube, das verdiente tatsächlich körperliche Züchtigung ... ).

Gruß,

Simon2.

OK, erstmal Danke!
Es funktioniert so wie gedacht wenn ich die Helper-Klasse im Helper.cpp Modul definiere.

Ich muss sie aber im Helper.h definieren, da die Methoden als inline eingefügt werden sollen (ist dies überhaupt richtig?).
Die Master-Klasse ist in Master.h deklariert und definiert.
Um das ganze so wie gewollt umzusetzen, muss ich also ein #include Helper.h in der Master.h setzen, sowie ein #include Master.h in der Helper.h.

Und da kracht es. Wieso, und was kann ich tun?

CStoll

Klar, daß es da kracht - solche Abhängigkeits-Ringe sind nie besonders gut. Die kannst du unterbrechen, indem du eine der Klassen forward-deklarierst.

(btw, zeig mal etwas Code)

Dazu müsste ich doch die unbekannte Helper-Klasse in der unbekannten Master-Klasse forward-deklarieren, was doch nicht geht, oder?

Wie bereits gesagt mache ich das alles im Header, da die Methoden inline gesetzt werden sollen.
Ist das überhaupt tatsächlich notwändig?

CStoll

konstante Katze schrieb:

Dazu müsste ich doch die unbekannte Helper-Klasse in der unbekannten Master-Klasse forward-deklarieren, was doch nicht geht, oder?

Wie gesagt - zeig mal etwas Code.

Wie bereits gesagt mache ich das alles im Header, da die Methoden inline gesetzt werden sollen.
Ist das überhaupt tatsächlich notwändig?

Wieso sollte es notwendig sein, die Methoden inline zu definieren?

Eigentlich gibt es das gleiche Problem auch ohne der inline-Definition:

//Master.h
#include Helper.h

class Master
{
  private:
    class Helper;
    Helper* helper;
    ...
  public:
    void fubar()
    {
       helper->help();
    }
    ...
};

//Helper.h
#include Master.h

class Master::Helper
{
  private:
    void help();
    ...
  public:
    ...
};

Ist die einzigste Lösung in Master.h alle Zugriffsmethoden von Master::Helper (forwared) zu deklarieren, oder gibt es da einen eleganteren Weg?

CStoll

konstante Katze schrieb:

Ist die einzigste Lösung in Master.h alle Zugriffsmethoden von Master::Helper (forwared) zu deklarieren, oder gibt es da einen eleganteren Weg?

Vermutlich ja (ich bin mir noch nichmal sicher, ob deine Konstruktion überhaupt standardkonform ist). Auf jeden Fall ist das #include "Helper.h" vor der Definition der Master-Klasse verkehrt.

Th

Wenn die Klassen 'Helper' etc. nicht nach außen hin sichtbar sein sollen, dann arbeite doch mit dem PrivateData-Idiom, d.h. du deklarierst alle privaten Daten nur in der cpp-Datei.

Beispiel:
// master.h

class Master
{
  private:
    class PrivateData;
    PrivateData *m_pData;
    ...
  public:
    ...

// master.cpp

#include "Helper.h"

class Master::PrivateData
{
  Helper *helper;
};

Master::Master()
{
   m_pData = new PrivateData();
}

Master::~Master()
{
   delete m_pData;
}

Simon2

Hi,

nur der Vollständigkeit halber: Geben Sie noch einen * dazu:

Th schrieb:

...

class Master
{
  private:
    class PrivateData;
    PrivateData* m_pData;
    ...

Das Problem ist, dass der OP ja gerne die Methoden inlinen will ... und da braucht's dann schon die Definition von PrivateData....

Gruß,

Simon2.