2dim Array ersetzen durch Klasse

[TheWho]

Hallo Leute,

heute brauche ich mal fachliche Hilfe

Also, ich muß Daten vektorisieren.

Diese Daten bekomme ich prima aus der Datei ausgelesen und in ein 2dim Array geschrieben, und auch wieder ausgegeben.

Mein Problem:

ich soll das Ganze eigentlich objektorientiert umsetzen. Mir fällt aber nichts ein, wie ich das als Klasse(n) beschreiben soll.

Wichtig ist, daß ich für jedes Element des Arrays nach oben, rechts, unten und links nach dem Inhalt gucken können muß - im 2dim Array kein Problem, aber mit Klassen bekomme ich es einfach nicht hin.

Dabei ist die Lösung sicher einfach und ich komme nur nicht drauf?

Danke im voraus!!

TheWho

Derzeit habe ich es etwa so:

class matrix 

{

private:

	float** feld; // Dynamisches zweidimensionales Array

	int zeilen, spalten, x, y; // Anzahl Zeilen und Spalten

	float fContent;


public:

	matrix(int zeilen, int spalten); // Konstruktor

	//matrix(const matrix&); // Copy-Konstruktor

	~matrix(); // Destruktor


	void set (int anzahl, ...); // Wertzuweisung

	void print (); // Ausgabe einer Matrix

	float getContent(int x, int y)

	{

	   return fContent;

	};


	void setContent(int x, int y, float c)

	{

	   fContent = c;

	};

};


main

{ blablub....

     //setzen Inhalt

     myRaster.setContent( iXDim, iYDim, <einzelner Content> );


    //Nachbarn angucken 

    lookNeighbours ( iNeighbours, iXDim, iYDim, myRaster );

}



void lookNeighbours(int* iNeighbours,	int iXDim,	 int iYDim, float myRaster)

{

   if ( ! (iYDim-1 < 1 ) )   //NORDEN  

   {

      if ( myRaster.getContent(iXDim, iYDim) == myRaster.getContent(iXDim-1, iYDim) ) 

	     iNeighbours[0] = 0;

	  else

	     iNeighbours[0] = 1;

   }


   if ( ! ( iXDim+1 > nXSize-1  ) )   //OSTEN

   {

      if ( faRaster[iXDim+1][iYDim] == faRaster[iXDim][iYDim] ) 

	     iNeighbours[1] = 0;

	  else

	     iNeighbours[1] = 1;

   }


   if ( ! ( iYDim+1 > nYSize-1 ) )   //SUEDEN   

   {

	  if ( faRaster[iXDim][iYDim+1] == faRaster[iXDim][iYDim] ) 

	     iNeighbours[2] = 0;

	  else

	     iNeighbours[2] = 1;

   }


   if ( !( iXDim-1 < 1 ) )   //WESTEN

   {

      if ( faRaster[iXDim-1][iYDim] == faRaster[iXDim][iYDim] ) 

	     iNeighbours[3] = 0;

	  else

	     iNeighbours[3] = 1;

   }

} 

[TheWho]

Huhu Mod(s),

ähm - peinlich, bin im Forum verrutscht. Könnte bitte einer den ins C/C++ Forum verschieben?

Danke! :nett:

TheWho

[Guybrush Threepwood]

Also ich hab nur mal auf deine Membervariablen geguckt und da bist du ja schon auf dem richtigen Weg.

Innerhalb deiner Klasse hast du ja so auch "nur" ein mehrdimensionales Array.

Jetzt brauchst du noch die Entsprechenden Funktion um mit dem Array arbeiten zu können.

Spontan fallen mir da folgende ein:

-Array anlegen

-Spalte/Zeile vergrößern oder verkleinern

-Einem Element im Array einen Wert zuweisen

-Wert eines bestimmten Elements abfragen

-Array freigeben

Damit sollte erstmal das Wichtigste abgedeckt sein.

[TheWho]

Hm, hab ich das Prinzip doch noch nicht verstanden?

Also ich hab nur mal auf deine Membervariablen geguckt und da bist du ja schon auf dem richtigen Weg.

Innerhalb deiner Klasse hast du ja so auch "nur" ein mehrdimensionales Array.

Jetzt brauchst du noch die Entsprechenden Funktion um mit dem Array arbeiten zu können.

Spontan fallen mir da folgende ein:

-Array anlegen

Ist das nicht der Konstruktor? Den hatte ich ja oben mit angegeben.

-Spalte/Zeile vergrößern oder verkleinern

Brauche ich eigentlich nicht. Die Größe des Arrays beziehe ich aus der Datei und damit initalisiere ich den Konstruktor. Oder?

-Einem Element im Array einen Wert zuweisen

Das sollte die Methode setContent() sein. Auch falsch?

-Wert eines bestimmten Elements abfragen

Eigentlich getContent() :hells:

-Array freigeben

Destruktor, oder? Das ist das Teil mit der Tilde davor. Dachte ich zumindest?

Damit sollte erstmal das Wichtigste abgedeckt sein.

Jo, danke erstmal. Allerdings ist damit mein eigentliches Problem noch nicht gelöst.

Ich hab Probleme damit, auf den Content eines anderen Objekts dieser Klasse zu gucken. Oder eher die Nachbarn halt. :confused:

HILFE :beagolisc

[Guybrush Threepwood]

Wie gesagt ich hab mir deinen Code nicht angeguckt :floet:

Ja das anlegen und das freigeben des Arrays kann/sollte im Konstruktor bzw. im Destruktor geschehen. Je nach Verwendungszweck kann es aber nicht schaden wenn man eine extra Funktion dafür hat.

Ich hab Probleme damit, auf den Content eines anderen Objekts dieser Klasse zu gucken. Oder eher die Nachbarn halt.

Das hab ich noch nicht so ganz verstanden.

[TheWho]

Wie gesagt ich hab mir deinen Code nicht angeguckt :floet:

Naja, eigentlich sollte man schon den gesamten Post lesen

Das hab ich noch nicht so ganz verstanden.

Meine Aussage im ersten Post war:

Wichtig ist, daß ich für jedes Element des Arrays nach oben, rechts, unten und links nach dem Inhalt gucken können muß - im 2dim Array kein Problem, aber mit Klassen bekomme ich es einfach nicht hin.

Und das ist weiterhin mein Problem. Ich weiß nicht, wie ich mit Objekten in den beiden Dimensionen des Ursprungs-Arrays "wandern" kann?!

[Guybrush Threepwood]

Hmm ich glaube du hast noch nicht so ganz verstanden was du da machst

Angenommen du stellst in deiner Klasse eine Funktion bereit der du den Index eines Elements übergibst und welche dann denn Wert des Elements eine Zeile höher liefert.

In dieser Funktion musst du doch nur genau das selbe machen wie du es machst wenn du keine Klasse hast und dann den Wert zurückgeben.

Als Beispiel und ungetestet würde ich mir das so vorstellen:

float get_oben(int x, int y)

{

    if (zeilen >= y && spalten >= x)

         return feld[y-1][x];

}

[/PHP]

EDIT: Das setzt natürlich voraus das das Array gleichmäßig aufgebaut ist und jede Zeile die gleiche Anzahl an Spalten hat.

[geloescht_Newlukai]

Wie sieht denn Dein Konzept aus?

Willst Du für jeden Wert, den Du früher im 2-dim. Array hattest, ein eigenes Objekt? Oder willst Du ein Objekt, das ein 2-dim. Array verwaltet?

Dem Quellcode nach möchtest Du das 2. Konzept umsetzen. Und in dem Fall kann ich mich meinem Vorredner nur anschließen. Denn innerhalb des Objekts kannst Du wie gewohnt auf Dein Array zugreifen.

Im ersteren Fall würde mir spontan das Wort "Liste" einfallen. Wenn ich mir das so durchdenke, ziemlich gewagter Ansatz. Für jede Zeile eine Liste, und jede Spalte wieder eine Liste, die mit den Zeilenelementen verkettet ist. Klingt irgendwie verdammt bescheuert und doch interessant. *grübel*

[TheWho]

Wie sieht denn Dein Konzept aus?

Willst Du für jeden Wert, den Du früher im 2-dim. Array hattest, ein eigenes Objekt? Oder willst Du ein Objekt, das ein 2-dim. Array verwaltet?

Dem Quellcode nach möchtest Du das 2. Konzept umsetzen. Und in dem Fall kann ich mich meinem Vorredner nur anschließen. Denn innerhalb des Objekts kannst Du wie gewohnt auf Dein Array zugreifen.

Im ersteren Fall würde mir spontan das Wort "Liste" einfallen. Wenn ich mir das so durchdenke, ziemlich gewagter Ansatz. Für jede Zeile eine Liste, und jede Spalte wieder eine Liste, die mit den Zeilenelementen verkettet ist. Klingt irgendwie verdammt bescheuert und doch interessant. *grübel*

Also, erstmal würde es mir reichen, das zweite Konzept umzusetzen, damit ich das Prinzip verstehe.

Ich befürchte allerdings, daß ich das erste Konzept irgendwann umsetzen muß, da ich zu jedem Wert voraussichtlich noch einen Wert eintragen muß (nämlich, ob das Feld bereits "betreten" wurde).

Oder würde es dafür auch reichen, in das Array statt des einen Werts einen Vektor oder eine map einzutragen?

Mein Problem ist wohl eher, daß ich von OO echt noch nicht viel Ahnung habe. Aber irgendwo muß ich ja anfangen. :floet:

[geloescht_Newlukai]

Hmm. Dann würde ich an Deiner Stelle mal OOP aufarbeiten. Denn etwas Grundwissen sollte man schon haben um dann die Zusammenhänge zu verstehen.

Leider habe ich bisher nur C++-Grundwissen und kenn' die OOP-Gegebenheiten dort nicht.

Jedenfalls sollte es möglich sein, einen Container zu schreiben. Dieser hat als Member ein 2Dim-Array und verschiedene Operationen um darauf zuzugreifen. Dein Code und die Erweiterung von Guybrush sehen gut aus. Im Prinzip mußt Du dann nur noch ein Objekt dieser Klasse instanziieren und handelst Deine Daten fast genau so wie direkt mit einem 2Dim-Array.

Beim 1. Konzept fiele mir auch die Möglichkeit ein, das 2. dahingehend zu erweitern, daß Du statt primitiven Datentypen einfach Objekte innerhalb Deines Containers sicherst. So hast Du die Einfachheit des 2. Konzepts mit der Anforderung mehrere Werte pro Feld zu sichern.

[TheWho]

Hi Ihrs,

danke für Eure Hilfe. Jetzt hat es erstmal geklappt. So falsch war das gar nicht, was ich hatte. Nur die Initialisierung des Arrays klappt nicht, das hab ich erstmal hardcodiert

Ich hab nächste Woche nen C++ Kurs, da soll mir der Dozent das mal hübsch beibringen, wie man ein dynamisches Array als Membervariable initialisiert :floet:

Aber ich komme jetzt schon mal weiter, und das ist die Hauptsache :nett:

Wie gesagt, danke vorerst!!

LG, TheWho

[Guybrush Threepwood]

Ich hab nächste Woche nen C++ Kurs, da soll mir der Dozent das mal hübsch beibringen, wie man ein dynamisches Array als Membervariable initialisiert :floet:

Indem du einfach ne Schleife drüber laufen lässt und den Initialisierungswert zuweist?

[TheWho]

Indem du einfach ne Schleife drüber laufen lässt und den Initialisierungswert zuweist?

Muß ich dafür nicht die Größe des Arrays kennen? Ich hatte das bisher so:

private:

   float feld**; // Dynamisches zweidimensionales Array

public:

   matrix(int x, int y) // Konstruktor mit Dimensionen und Anfangspixel

   {

       zeilen = y;

       spalten = x;

       iXAct = 0;

       iYAct = 0;

       float feld[zeilen][spalten]; 

    }; 

Ich wollte also im Konstruktor dem Array seine Dimensionen zuweisen. Danach das befüllen klappt schon (jetzt hardcodiert).

[geloescht_Newlukai]

Muß ich dafür nicht die Größe des Arrays kennen?

In zeilen und spalten stehen doch die Längen. Mußt nur noch sowas schreiben:

private:

   float feld**; // Dynamisches zweidimensionales Array

public:

   matrix(int x, int y) // Konstruktor mit Dimensionen und Anfangspixel

   {

       zeilen = y;

       spalten = x;

       iXAct = 0;

       iYAct = 0;

       float feld[zeilen][spalten]; 

              for(int i = 0; i < zeilen; i++) {

             for (int j = 0; j < spalten; j++) {

                   feld[i][j] = 0.0f;

             }

        }


    }; 

[Guybrush Threepwood]

Muß ich dafür nicht die Größe des Arrays kennen?

Du reservierst doch den Speicher für das Array, also weißt du doch auch wie groß das ist.

[TheWho]

In zeilen und spalten stehen doch die Längen. Mußt nur noch sowas schreiben:

private:

   float feld**; // Dynamisches zweidimensionales Array

public:

   matrix(int x, int y) // Konstruktor mit Dimensionen und Anfangspixel

   {

       zeilen = y;

       spalten = x;

       iXAct = 0;

       iYAct = 0;

       float feld[zeilen][spalten]; 

              for(int i = 0; i < zeilen; i++) {

             for (int j = 0; j < spalten; j++) {

                   feld[i][j] = 0.0f;

             }

        }


    }; 

So ähnlich (in einer Methode) habe ich das auch erst gemacht, aber der meckert der Compiler... Darum dachte ich, ich hätte etwas falsch gemacht.

Es geht, wenn ich der Membervariablen sofort die Dimensionen zuweise, aber dann ist es ja nicht mehr dynamisch.

[geloescht_Newlukai]

Es geht, wenn ich der Membervariablen sofort die Dimensionen zuweise, aber dann ist es ja nicht mehr dynamisch.

Ein Array ist in seiner Größe fest, d. h. NICHT dynamisch. Sobald eine andere Größe festgelegt wird, mußt Du das bestehende Array verwerfen und ein neues initialisieren. Daher verstehe ich Dein Problem jetzt nicht.

Erläuter' vielleicht noch einmal ganz konkret die Anforderungen.

[TheWho]

Ein Array ist in seiner Größe fest, d. h. NICHT dynamisch. Sobald eine andere Größe festgelegt wird, mußt Du das bestehende Array verwerfen und ein neues initialisieren. Daher verstehe ich Dein Problem jetzt nicht.

Erläuter' vielleicht noch einmal ganz konkret die Anforderungen.

Das meinte ich nicht mit dynamisch, sorry. Dynamisch hieß, zur Laufzeit die Größe festlegen. Also die Dimensionen aus einer Datei einlesen und das Array dann mit diesen Werten initialisieren.

Da ich aber gestern und vorgestern den C++-Kurs hatte, und das Problem dort gelöst werden konnte, hat sich das eh erledigt

Trotzdem vielen Dank an alle, die mir versucht haben, zu helfen!

[geloescht_Newlukai]

Das meinte ich nicht mit dynamisch, sorry. Dynamisch hieß, zur Laufzeit die Größe festlegen. Also die Dimensionen aus einer Datei einlesen und das Array dann mit diesen Werten initialisieren.

Aso. Jetzt versteh' ich das.

Trotzdem vielen Dank an alle, die mir versucht haben, zu helfen!

np