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!

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
  {
    ...
  };
  ...
};

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.

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?

(btw, 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?

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?

//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?

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.

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

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.