2-D Array

haweder

Grünschnabel
Ich habe ein 2-d array array[x][y].. das problem ist es beim testen alles aber sobald ich dann das array vergrössere wirds zwar compiliert aber das programm stürzt ab so ab 300 mal 300 Feld! aber ich brauch ein 2000 mal 2000 Feld also.

...
#define MAX_X 2000
#define MAX_Y 2000

void.........
{
int Feld[MAX_X][MAX_Y];
...
}
Was kann ich machen?
 
Also, du brauchst ein 2000*2000 grosses int-Array? Poste mal den ganzen Schnipsel. So wie es aussieht, würde das mit seinen vollen Grösse (vermutlich 16MB) auf dem Stack erzeugt werden, und der ist wahrscheinlich kleiner eingestellt. Also: Stack grösser machen (kann man bei Codegeneration irgendwo, da wo auch Optimierungseinstellungen zu machen sind), oder das Array auf dem Heap anlegen (meine Empfehlung) und über Pointer ansprechen:
Code:
int* Feld = new int[ 2000 * 2000 ];
Nach Gebrauch das deleten nicht vergessen:
Code:
delete[] Feld;
Feld = 0;

Das sollte gehen, auch wenn ich das mit den zwei Dimensionen gerade nicht hinbekomme. Würde sowieso zu boost::multi_array raten... :)
 
Moin!

@Kachel
Schonmal ausgerechnet, wie viele Variablen du da erstellst? 4Millionen! 4.000.000! Ok, dass du die brauchst keine Frage. Eine Integer-Variable hat bekanntlich 8Bit. 4.000.000 * 8 = 32.000.000.

So. Das entspricht etwa 30,5 MB, die du da in den Speicher haust.
Grüße,
Jens
 
Also ich lese ne karte mit höhenprofil ein die in ascii gespeichert ist ein..ich würde hier gerne F_BREIT UND F_LAENGE auf 2000 vergrössern das mit dem pointer zeiger zeugs ist schon zu spät weil ich schon alle funktionen geschrieben hab und auch getestet und will nich nochmal das alles machen! war ne heiden arbeit!

#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
#include <ctype.h>
#include <string.h>
#include <math.h>

/* Festlegung der einstellbaren Parameter */
#define F_BREITE 50
#define F_LAENGE 50
#define F_HOEHE 4
#define MAXSTR 15

/*globale Variable*/
FILE* Hoehe_z;
int hoehenint=1000;
int reichweite=1750;

...
paar funktionen
...
void main()
{
/**********************************************/
/* Variablendeklaration und - initialisierung */
/**********************************************/
/* Aufspannen des Felds */
int Feld[F_BREITE][F_LAENGE];
float Sicherheit[F_BREITE][F_LAENGE][F_HOEHE];
float sichtchance[F_BREITE][F_LAENGE][F_HOEHE];
/* Deklaration und Initialisierung der Variablen */
int Zeile = F_LAENGE , Spalte = F_BREITE, Hoehe=F_HOEHE;
int Wert = 0;
int Abbruch = 1;
int i=0;
int j=0;
int HVZ=0;
int HVS=0;
int n=0;
int m=0;
int z=0;
int s=0;
int Hoehenangabe=1;
char text[]="abcd";
char name[MAXSTR];
float r;
double Anzmaxpkt=0;
float maxr;
char head[]="file_title = ";
int rows=0,columns=0,h1,h2;
int h3,h4;
int ro;
int co;
float lemx,lomy,rimx,upmy;
int minh=10000,maxh;
float eingrad;
float rasterx,rastery;


eingrad=111142.57;

...
...

/* Initialisieren des flugfeldes */
for(Zeile=0; Zeile < ro; Zeile++)
{
/* Zaehlschleife fuer Zeilen */
for(Spalte=0; Spalte < co; Spalte++)
{
for(Hoehe=0; Hoehe < F_HOEHE; Hoehe++)
/* Zaehlschleife fuer Spalten */
Sicherheit[Spalte][Zeile][Hoehe]=0;

}
}
/*öffnen Hoehendatei*/
Hoehe_z = fopen (name,"r");
if ( Hoehe_z == NULL)
{
printf("\n Fehler beim Einlesen der Hoehendatei!");
printf(" Wird komplett auf 0 gesetzt!");
/* Zaehlschleife fuer Zeilen */
for(Zeile=0; Zeile < ro; Zeile++)
{
/* Zaehlschleife fuer Spalten */
for(Spalte=0; Spalte < co; Spalte++)
Feld[Spalte][Zeile]=3;
}
}
else
{
/* Einlesen Hoehendaten*/
/* Zaehlschleife fuer Spalten */
for(Zeile=ro-1; Zeile >=0 ; Zeile--)
{
/* Zaehlschleife fuer Zeilen */
for(Spalte=0; Spalte <co ; Spalte++)
{

fscanf (Hoehe_z, "%d%s" ,&Hoehenangabe, &text );
Feld[Spalte][Zeile]=Hoehenangabe;
if (Feld[Spalte][Zeile]>maxh)
{
maxh=Feld[Spalte][Zeile];
}
if (Feld[Spalte][Zeile]<minh)
{
minh=Feld[Spalte][Zeile];
}

}
}

}
fclose(Hoehe_z);
 
das mit dem pointer zeiger zeugs ist schon zu spät weil ich schon alle funktionen geschrieben hab und auch getestet und will nich nochmal das alles machen! war ne heiden arbeit!
Tja, sorry, aber das läuft so oder so auf ein Umgebastele deinerseits hinaus. Was Anderes geht nicht. Ist auch nicht so unüblich und jedenfalls eine gute Übung.

Nebenbei: Wenn du Code postest, verwende bitte Codetags! Unformatierter Code ist Folter.
 
Hi,

Je nach dem wie du die Daten brauchst,könnte man sie auch nacheinander bearbeiten.
Vieleicht zeilenweise, also je 2000 Stück.

Oder du macht es wie Kachelator gesagt hat, während der laufzeit aufn Heap.

Eine Verkettete Liste könnte ich auch noch anbieten, aber da musst du erst recht, und noch viel mehr an deinem Code basteln.

Mfg Col.Blake
 
Wie soll denn eine Liste sein Problem lösen?

Das soll das Problem der Datenmenge nicht lösen.
Es ist nur eine weitere Art die Daten zu halten ohne sie in den Stack zu schaufeln.
Genauso wie dein Zeiger auf das 2D-Array. Ist nur eben komplexer zu programmieren.
Ich geb ja zu, dass das ein wenig "mit Kanonen auf Spatzen" geschossen ist. ;)

Mfg Col.Blake
 
Das würde den Speicherbedarf auch mindestens verdoppeln. Abgesehen davon ist ein Liste nicht besonders gut geeignet, eine zweidimensionale Matrix zu repräsentieren.

Und dann kämen ja noch diese Array dazu:
int Feld[F_BREITE][F_LAENGE];
float Sicherheit[F_BREITE][F_LAENGE][F_HOEHE];
float sichtchance[F_BREITE][F_LAENGE][F_HOEHE];

Wäre vielleicht vernünftig, bei 300x300 oder so zu bleiben.
 
Zurück