Anfängerprob, verkettete Liste, Klassenkonstruktor verursacht Speicherzugiffsfehler

[Markuhn]

Hi!

Ich bin dabei eine Klasse zu schreiben über die ich auf ein double array zugreifen kann, bei dem jeder Eintrag seine Nachbarn kennt. Schlussendlich soll damit ein elekt. Feld berechnet werden also liegt mein Hauptaugenmerk auf der Zugriffsgeschwindigkeit.

Also dachte ich mir ich lasse alle Elementadressen und die dazugehörigen Nachbaradressen in einem pointerarray speichern und greife darüber zu. Dies wollte ich im Konstruktor machen, allerdings bekomme ich beim Erzeugen eines Elements einen Speicherzugriffsfehler.

Sollte der Titel irreführend sein entschuldige ich mich, ein Bekannter sagte mir was ich versuche sei eine "verkettete Liste" allerdings fand google darunter nur dynamische Speicherverwaltung. Mir fiel aber für mein Anliegen keine andere/bessere Bezeichnung ein.

Hier ist der Code der Klasse ich hoffe jemand kann mir sagen was ich falsch mache.

#ifndef NACHBARFELD_H

#define NACHBARFELD_H


#include <iostream>


using namespace std;


#define XMAX 1000

#define YMAX 1000

#define IEND (XMAX*YMAX)


class Nachbarfeld

{

        public:


                Nachbarfeld()

                {

                        unsigned int index = 0;

                        for(unsigned int i = 0; i < XMAX; i++)

                        {

                                for(unsigned int j = 0; j < YMAX; j++)

                                {

                                        parr[index][0] = &arr[i][j];


                                        if((i-1) < 0) parr[index][1] = &arr[XMAX-1][j];

                                        else parr[index][1] = &arr[i-1][j];


                                        if((i+1) > (XMAX-1)) parr[index][2] = &arr[0][j];

                                        else parr[index][2] = &arr[i+1][j];


                                        if((j-1) < 0) parr[index][3] = &arr[i][YMAX-1];

                                        else parr[index][3] = &arr[i][j-1];


                                        if((j+1) > (YMAX-1)) parr[index][4] = &arr[i][0];

                                        else parr[index][4] = &arr[i][j+1];


                                        index++;

                                }

                        }

                }


                double neib(unsigned int x,unsigned int y,short n)

                {

                	#ifdef DEBUG

                        if(x>XMAX||y>YMAX||n>4||n<0)

                        {

                                cerr << "\n\n\tSpeicherschutzverlezung beim Aufruf von Nachbarfeld.neib(x,y,n) !\n";

                                return 0;

                        }

                	#endif

                        return *parr[x*YMAX+y][n];

                }


                double neib(unsigned int i,short n)

                {

                	#ifdef DEBUG

                        if(i>IEND||n>4||n<0)

                        {

                                cerr << "\n\n\tSpeicherschutzverlezung beim Aufruf von Nachbarfeld.neib(i,n) !\n";

                                return 0;

                        }

                	#endif

                        return *parr[i][n];

                }


                unsigned int getx(unsigned int i){return i/YMAX;	}

                unsigned int gety(unsigned int i){return i%YMAX;	}

                unsigned int geti(unsigned int x,unsigned int y){return x*YMAX+y; }



        private:

                double *parr[IEND][5];

                double arr[XMAX][YMAX];


};


#endif // NACHBARFELD_H

Danke schon mal im Vorfeld für eure Hilfe.

[Markuhn]

PS.: Die Rückgabewerte von neib sind natürlich pointer auf die jeweiligen Elemente

Das casting hab ich weggelassen weil es mir nicht sinnvoll erschien.

                double* neib(unsigned int x,unsigned int y,short n)

                {

                        if(x>XMAX||y>YMAX||n>4||n<0)

                        {

                                cerr << "\n\n\tSpeicherschutzverlezung beim Aufruf von Nachbarfeld.neib(x,y,n) !\n";

                                return 0;

                        }

                        return parr[x*YMAX+y][n];

                }


                double* neib(unsigned int i,short n)

                {

                        if(i>IEND||n>4||n<0)

                        {

                                cerr << "\n\n\tSpeicherschutzverlezung beim Aufruf von Nachbarfeld.neib(i,n) !\n";

                                return 0;

                        }

                        return parr[i][n];

                }

Bearbeitet 9. Mai 2011 von Markuhn

[Klotzkopp]

Zeig mal, wie du die Klasse benutzt. Auf den Stack wird die kaum passen.

[Markuhn]

Erstmal danke für die Hilfe

Das Array muss nicht unbedingt 1000x1000 sein aber 200x200 möchte ich schon realisieren.

Ich wollte die Klasse so benutzen:

#include <iostream>

#include <cmath>

#include "Nachbarfeld.h"


using namespace std;



int main()

{

	const double prec =0.2;

	bool Bedingung[2];

	Nachbarfeld arr;


	for(int i = 0;i< IEND;i++) *arr.neib(i,0) = 0;






	while (Bedingung[0])

	{

		Bedingung[0] =1; Bedingung[1] =1;


		//Randwerte setzen

		//Dipol:

		*arr.neib(XMAX/2,YMAX/4,0) = 1;

		*arr.neib(XMAX/2,YMAX*3/4,0) = -1;    


		for(int i = 0;i< IEND;i++) 

		{

			double hilf = ( *arr.neib(i,1) + *arr.neib(i,2) + *arr.neib(i,3) + *arr.neib(i,4) )/4;


			if( abs( *arr.neib(i,0) - hilf) < prec && Bedingung[1]==1) Bedingung[0] = 0;

			if( abs( *arr.neib(i,0) - hilf) >= prec)

			{ 

				Bedingung[1] = 0;

				Bedingung[0] = 1;

			}

			*arr.neib(i,0) = hilf;

		}

	}


	// Ausgabe des Felds fstream...

}

Bearbeitet 9. Mai 2011 von Markuhn

[Klotzkopp]

Das Array muss nicht unbedingt 1000x1000 sein aber 200x200 möchte ich schon realisieren.

Wenn deine Klasse zu groß für den Stack ist, musst du sie eben im Free Store anlegen:

// Statt Nachbarfeld arr;

auto_ptr<Nachbarfeld> p(new Nachbarfeld);

Nachbarfeld& arr = *p;

[/code]


Damit scheint es bei mir zu laufen.

[Markuhn]

Danke vielmals, da wäre ich nie drauf gekommen!

Und schon wieder was gelernt