Zeigerarray auf Structelemente in anderer Klasse

[_iop]

Hallo!

Ich habe eine Klasse, in der ich ein Struct definiere. Davon lege ich in dieser Klasse viele Objekte/Variablen in einem Array an.

Dann habe ich eine zweite Klasse. Objekte dieser Klasse werden in der ersten Klasse erstellt. Jedes dieser Objekte soll nun ein Array haben, welches Zeiger beinhaltet, die auf einzelne "Structvariablen" in der ersten Klasse zeigen.

..ich schreibs besser nochmal als Code auf:

class ersteKlasse
{
  private:
    struct meinStruct
    {
      int a, b, c;
      bool d;
    } structVar[100];

    //...
}

class zweiteKlasse
{
  private:
    ArrayVonZeigernAufElementeVonMeinStruct[max100];

    //...
}

Leider kriege ich das nicht hin. Ist es überhaupt möglich? Kann mir eventuell jemand helfen?

Vielen Dank schon einmal im Voraus!

[simon.gysi]

Leider kriege ich das nicht hin

Ich nehme an, das bedeuted einen Kompiler Fehler.
Nächstes mal unbedingt dein Problem genau Beschreiben und alle Fehlermeldungen exakt hier reinposten.

Damit Du dein Struct aus Klasse1 in Klasse2 verwenden kannst musst Du es public machen (oder als friend deklarieren, empfehle ich nicht!).

Simon

[T0bi]

Man könnte natürlich auch einfach eine Methode schreiben in Klasse 1, die dann als Schnittstele dient?

Gruß Tobi.

[_iop]

Danke erstmal für die schnelle Antwort!

Hm, ok, ich gebe zu, mich da schwammig ausgedrückt zu haben, sorry. Was ich eigentlich meine, ist, dass ich mir gar nicht vorstellen kann, wie ich das überhaupt implementieren kann. Compilerfehler habe ich nicht, da ich gar nicht weiß, wie ich das schreiben müsste...

Also über eine getStruct() Methode würde das gar nicht gehen? Wie würde ich aus dem Struct ein "friend" Struct machen und warum empfiehlst Du das nicht?

Danke nochmal!

[_iop]

Ah, also doch eventuell eine "getZeigerAufElementVonStruct()"Methode?

[iop]

Ach ja, noch eine Frage:

Wie würde der Typ des Zeigerarrays aussehen? Der "meinStruct" Typ aus der ersten Klasse ist doch in der zweiten Klasse unbekannt, oder?

[simon.gysi]

class ersteKlasse 
{ 
  public: 
    struct meinStruct 
    { 
      int a, b, c; 
      bool d; 
    };
  private:
    meinStruct structVar[100];

   public:
    meinStruct* getMeinStructArray() { return structVar; }
    //... 
} 

class zweiteKlasse 
{ 
  private: 
    ersteKlasse::meinStruct* meinStructArray;  // muss irgendwann initialisiert werden (z.B. mit dem Wert aus getMeinStructArray(..))

    //... 
}

[iop]

Super, das sieht für mich verständlich aus.
Habe es eben ausprobiert, ich bekomme aber diese Fehlermeldungen:

error C2653: 'ersteKlasse': Keine Klasse oder Namespace
error C2143: Syntaxfehler: Es fehlt ';' vor '*'
error C4430: Fehlender Typspezifizierer - int wird angenommen. Hinweis: "default-int" wird von C++ nicht unterstützt.
error C4430: Fehlender Typspezifizierer - int wird angenommen. Hinweis: "default-int" wird von C++ nicht unterstützt.

Ach ja, die Objekte der zweiten Klasse werden so erstellt:

ersteKlasse
{
  private:
    zweiteKlasse* zweiteKl;
  //...
  public:
    ersteKlasse(){zweiteKl = new zweiteKlasse[anzahl];
}

Was stimmt da nicht?

Danke nochmal vielmals für die bisherige schnelle Unterstützung!

[simon.gysi]

Die Klass ersteKlasse ist in der zweitenKlasse unbekannt.
Header includieren. (oder Forward Dekl.)

[iop]

Hm.. also ich habe jetzt folgendes geschrieben:

//zweiteKlasse.h

#include "ersteKlasse"

class ersteKlasse

zweiteKlasse
{
  privat:
    ersteKlasse::meinStruct* meinStructArray;
}

Der Compiler kennt jetzt wohl die zweiteKlasse, da ich in Visual Studio nach Schreiben des zweiten Doppelpunktes die Auflistung der Methoden und Variablen aufgelistet bekomme.
Leider bekomme ich beim compilieren echt viele Fehler. Alle sind in der erstenKlasse und beziehen sich auf alle Variablen, Methoden und Objekte, die mit der zweiten Klasse zu tun haben.

Übrigens habe ich eine main Funktion (es handelt sich um eine WIN32 Anwendung), in der alle meine Headerdateien aufgelistet sind. Die "ersteKlasse" ist in meinem Projekt quasi eine Manageklasse, die alle anderen (zB die zweiteKlasse) aufruft etc und die selbst von der Mainfunktion aufgerufen wird.

Tut mir leid, wenn ich mich zu doof anstelle, aber ich bin noch ziemlich unerfahren. Das Stichwort "Forward Deklaration" habe ich heute auch zum ersten Mal bewusst gehört...

[camper]

Die Definition der ersten Klasse benötigt den Namen zweiteKlasse - eine bloße Deklaration genügt.
Die Definition der zweiten Klasse hängt von der Definition der ersten Klasse ab (wegen des Bezeichners ersteKlasse::meinStruct).
Die Definition des Konstruktors der ersten Klasse hängt wiederum von der Definition der zweiten Klasse ab (wegen new).
Schlussfolgerung: Der Konstruktor der ersten Klasse kann nicht inline in der Klassendefinition definiert werden sondern erst, nachdem zweiteKlasse (und davor wegen 1. Bedingung auch ersteKlasse) definiert wurde.

Die Reihenfolge sieht also so aus

class zweiteKlasse;

class ersteKlasse
{
  public:
    struct meinStruct
    {
      int a, b, c;
      bool d;
    };
  private:
    meinStruct structVar[100];
  private:
    zweiteKlasse* zweiteKl;
  //...
  public:
    ersteKlasse();
}

class zweiteKlasse
{
  private:
    ersteKlasse::meinStruct* meinStructArray;
}

ersteKlasse::ersteKlasse() { zweiteKl = new zweiteKlasse[anzahl];

[iop]

Ja, das alles leuchtet mir ein, und ich meine, es auch so zu haben (Ok, Post von 14:53 sieht anders aus, ich wollte das nur verkürzt darstellen hier und bin nicht davon ausgegangen, dass es Probleme macht..)

Ich poste nochmal, wie das Ganze bei mir aussieht:

//main.h
#include "zweiteKlasse"
#include "dritteKlasse" //etc
#include "ersteKlasse"
//...

//main.cpp
#include "main.h"

ersteKlasse ersteKl;

int WINAPI WinMain(...)
{
  ersteKl.eineMethode();
}

//ersteKlasse.h

class zweiteKlasse;

class ersteKlasse
{
  public:
    struct meinStruct
    {
      int a, b, c;
      bool d;
    };
  private:
    meinStruct structVar[100];
  private:
    zweiteKlasse* zweiteKl;
  //...
  public:
    ersteKlasse();
};

//zweiteKlasse.cpp

#include "main.h"

ersteKlasse::ersteKlasse()
{
  zweiteKl = new zweiteKlasse[anzahl];
}

//zweiteKlasse.h

#include "andereKlasse.h"

class ersteKlasse;

class zweiteKlasse
{
  private:
    ersteKlasse::meinStruct* meinStructArray;
};

//zweiteKlasse.cpp

#include "main.h"
//mache irgendwas...

Diese Version bringt zumindest die wenigsten Fehler... sechs mal diese Fehlermeldungen:

error C2027: Verwendung des undefinierten Typs "ersteKlasse"
zweiteKlasse.h(7): Siehe Deklaration von 'MainApplication'
zweiteKlasse.h(77) : error C2143: Syntaxfehler: Es fehlt ';' vor '*'
zweiteKlasse.h(77) : error C4430: Fehlender Typspezifizierer - int wird angenommen. Hinweis: "default-int" wird von C++ nicht unterstützt.
zweiteKlasse.h(77) : error C4430: Fehlender Typspezifizierer - int wird angenommen. Hinweis: "default-int" wird von C++ nicht unterstützt.

Echt jetzt, ich bin total verwirrt. Bisher dachte ich, alles zu durchschauen, aber das hier bringt mich aus dem Konzept...

@drakon: ja, sorry, war nur ein Flüchtigkeitsfehler beim Aufschreiben...

[drakon]

Eine Klassen Deklaration endet immer mit ;..

[iop]

camper schrieb:

Die Definition der ersten Klasse benötigt den Namen zweiteKlasse - eine bloße Deklaration genügt.

Darüber habe ich nochmal nachgedacht. Die Datei "ersteKlasse.h" wird bei mir ja von der main.h eingebunden. Deshalb denke ich, dass eine Deklaration der zweitenKlasse in der "ersteKlasse.h" nicht nötig ist.

..momentan werden die oben genannten Fehler zur Zeile 10 gemacht:

/zweiteKlasse.h

#include "andereKlasse.h"

class ersteKlasse;

class zweiteKlasse
{
  private:
    ersteKlasse::meinStruct* meinStructArray;
};

Ist die Struktur meines Projektes denn generell sinnvoll (also die includes in der main.h, die Erstellung des ersteKlasse Objektes in/über der main.cpp)?

Wie könnte ich denn jetzt weiter vorgehen? Hat noch jemand einen Tip bitte?