Hallo, ich habe (nach dem ich ein paar Tage dran gewerkelt habe) festgestellt dass ich ein grundlegendes Designproblem habe.

Zu erst: was will ich überhaupt.
Ich habe verschiedene Körper, deren Position in zwei Koordinatensysteme angegeben sind. Die Koordinatensysteme möchte ich jeweisl in das andere umrechnen können.

Meine Idee war zwei Klassen ELEM und COOR zu erstellen die eine Funktion enthalten um mit der Übergabe von der einen Klasse die andere Klasse berechnen können.

Das sah bei mir nun so aus:

class COOR
{
  private:
    double coor[3];
    double velo[3];

  public:
    /// Constructors
    COOR(double _x, double _y, double _z, // ... usw. 
          ) : 
          coor[0](_x), coor[1](_y), // ... usw.
      { }

    COOR(ELEM _Elem, double _GM) :
      {
        Calc(_Elem, _GM);
      }

    // Memberfunctions
    double getX();
    double getY();
    // ... usw. 

    void setX(double) const;
    void setY(double) const;
    // ... usw. 

    void Calc(ELEM, double);
};

class ELEM
{
  private:
    double a;
    double e;
    double i;
    // ... usw. 

  public:
    /// Constructors
    ELEM(double _a, double _e, // ... usw
         ) : a(_a), e(_e), // ... usw. 
      { }
          
    ELEM(COOR _Coor, double _GM) :
      {
        Calc(_Coor, _GM);
      }

    // Memberfunctions
    double getA();
    double getE();
    // ... usw. 

    void setA(double) const;
    void setE(double) const;
    // ... usw. 

    void calcCoor(ELEM, double);
};

Wie ich (leider etwas spät) festgestellt habe, brauche ich die eine Klasse um die andere aufzurufen

Weiß jemand Rat, wie ich mich aus diesem Schlamassel retten kann?

Ich hatte auch schon überlegt alles in eine Klasse zu schreiben, jedoch würde es einerseits dadurch recht unübersichtlich werden (vllt kommt ja mal noch ein weiteres Koordinatensystem hinzu) und zum anderen habe ich noch keine elegante Lösung parat um die KoordSysteme mit nur einem Parametersatz eines Systems alle anderen richtig zu initialisieren.

Gruß,
HarryKane

Die Implementation der Konstruktoren musst du aber eventuell noch in die cpp auslagern.

Darum habe ich es jetzt beide Klassen in einen Header geschrieben. Sie gehören ja eh recht eng zueinander.

Die Implementation der Konstruktoren musst du aber eventuell noch in die cpp auslagern.

Stimmt, dass geht ja auch ...

Ja die Idee hatte ich im Prinzip auch schon, aber das Problem war, dass es dann zu doppelt Initialisierungen kam. Wenn ich diese forward-Deklaration nur bei einem Header benutze, dann ist es immer kritisch, welchen Header man zu erst einfügt.

Wo ist dabei etwas kritisches?

Wenn man Forward-Declaration verwendet, wird garkein entsprechender Header eingefügt (erst im Source sieht es anders aus).