Hi,

ich habe folgendes Problem:
ich will eine 2d map in ein 2dimensionales array einlesen.
Dafür unnötig speicher verbraten wäre ja sinnlos (also z.B. gleich char[256][256] definieren)
Ich hab dann folgende Methode gefunden:
Quellcode:
char *pCharArray = NULL;
pCharArray = (char*)malloc(iAnzahlderFelder*sizeof(char));


geht das auch für ein zweidimensionales Array ?
Oder würdet ihr die Mapdaten ganz anders speichern ?

.-.-.-.
cya Tiger

ich würde sagen probier es aus ;)

aber vieleicht wenn es ein grösseres projekt is wo maps unterschiedlich gross sind würde ich ne verketete liste nehmen ... weis nich obs sin macht

aber wenn maps immer gleich gross sind kannste doch ne feste grösse nehmen

und mal nochwas char für ne map oder is das DOS wo du dann mit den ╝ ...

was ich aber auch nich verstehe wie willst du aus einem zeichen einen array machen ?( char *pCharArray = NULL; ) das ist doch nir 1 speicherplatz

wie gesagt nimm ne verkette liste die dürfte eigendlich gehn

Coding Center --- Tutorials über Programmierung und andere Themen
Amazon Preisbeobachung mit Preisalarm

ich würds ja so machen:

pCharArray = (char *)malloc(iAnzahlFelder);

und dann auf die einzelnen felder zugreifen mit:

int 2dindex(int x, int y)
{
return y * iGroesseY + x;
}

Mar 01 01:10:13 <voice> jo
Mar 01 01:10:40 <voice> bis dann ^^
Mar 01 01:11:20 <Archangel> jo
**** ENDING LOGGING AT Tue Mar 1 01:58:13 2005

map haben keine feste Größe, deshalb ja...

@Archangel: ja, ich werde dann alles in ein normales array werfen.
MGS ist das geilste Game ever !!! *g*

@KoD: is net DOS...ich hab mein system nur so:
auf der map ist 0 erde, 1 gras, A ein gebäude und so hat eben alles ein Zeichen aus dem ASCII-System. Meine Map braucht dann weniger Speicherplatz wenn ich es als char auswerte, denn z.B.
'A' braucht 1 byte aber '255' schon drei und das ist ja unnötig...

wenn ich ein Array möchte darf ich ja aber nicht char *pCharArray[x][y] machen sonst bekommt ich ja ein Array mit pointern oder nicht ?

also Quellcode:pCharArray = (char*)malloc(iAnzahlderFelder*sizeof(char));
macht das ganze zu einem eindimensionalem array, so steht das zumindest auf der page die ich gefunden hab.

.-.-.-.
cya Tiger

Das mit dem mehreren Dimensionen stimmt, aber ich würde einfach nen unsigned int Array machen, dann kannst du mehrere Millionen verschiedener Terrain-Typen machen und es ist Prozesor-"Optimiert" (bit alignment).

Quellcode:{
  unsigned int *pnMap = 0;

  if(!(pnMap = malloc(nWidth * nHeight * sizeof(unsigned int))))
    return 0xFF; //or whatever to return on error
}

georg-wicherski@pixel-house.net | http://www.pixel-house.net/ - Coding Resource| http://www.google.de/

des hat was @OneStone ;)
...thx an alle !

.-.-.-.
cya Tiger

muss da nicht ein unsigned int * -cast hin? ich glaube nicht jeder compiler nimmt den code so an.

Quellcode:{
  unsigned int *pnMap = 0;

  if(!(pnMap = (unsigned int*)malloc(nWidth * nHeight * sizeof(unsigned int))))
    return 0xFF; //or whatever to return on error
}

den wert an einer postition x y im array bekommst du so (breitenposition x, längenpostition y):

Quellcode:
*(pnMap+x*nHeight+y)


natürlich muss dafür x<=nWidth und y<=nHeight sein.

Entities: HL | HL²
Kompilierfehler
r_speeds | mehr über r_speeds

ok stimmt trotzdem würde ich da ne verkettete liste machen, nimmt nur so viel speicher wie es braucht und ist eigendlich auch recht schnell

Coding Center --- Tutorials über Programmierung und andere Themen
Amazon Preisbeobachung mit Preisalarm

OMFG

Einstein: ein char ist per Definition ein Byte groß, und ein Byte ist auf praktisch jedem Prozessor ein "native"-Datentyp.

King of Darkness: Nein, eine verkette Liste ist eine absolut dumme Idee, weil sie _viel_ zu viel Speicher verbraucht. Bei der vernünftigen Methode (= 2D-Array mit y*w + x in einem 1D-Array codiert) benötigst du (Anzahl der Felder * sizeof(felddaten)) Bytes. Bei einer vierfach Linked List (in x- und y-Richtung) brauchst du (Anzahl der Felder * (sizeof(felddaten)+4*sizeof(void*))) Bytes. Wenn du nur ein Byte pro Feld brauchst, dann ist daß das 17-fache an Speicherverbrauch!
Abgesehen davon ist Random Access auf Linked Lists sehr viel langsamer als auf einfache Arrays.

cu,
Prefect

Widelands - Gemütliche Aufbaustrategie, Free Software
Noch ein Blog - Lerne, wie die Welt wirklich ist, aber vergiss niemals, wie sie sein sollte.

Prefect: Leider gibt es noch keine [sarkasmus] oder [ironie]-Tags, sonst hättest du meinen Post warscheinlich anders verstanden... (hab ja schon verscuht das mit den "" deutlich zu machen) ;o]

Leviathan: Das mit dem cast stimmt, aber das rausfinden einer Position geht so einfacher (<- Ansichtssache): pnMap[nX * nWidth + nY]

georg-wicherski@pixel-house.net | http://www.pixel-house.net/ - Coding Resource| http://www.google.de/

@onestone: hmm hast recht, ist einfacher, hätte ich eigentlich acuh drauf kommen können. das führt aber die gleiche zeigerarithmetische operation aus wie mein code, nur eben anders formuliert. meins ist das, auf das man kommt, wenn man die position eines wertes im speicher herleitet, deins ist das selbe für tippfaule umformuliert (ist auch nicht so fehleranfällig wie meins).

das cast iat afaik compilerabhängig, da malloc ein void* zurückgibt, also einen zeiger auf irgentwas (muss nur eine variable sein, ein funktionszeiger sieht anders aus). den muss man natürlich entsprechend umwandeln, da man ja schlecht die ganze zeit mit einem zeiger unbestimmten typs arbeiten kann und ihn dann auch noch dereferentiert.

hier würde ich auch keine linked list nehmen, das braucht, wie perfect schon geschrieben hat, mehr speicher, ist langsamer (eine liste abwandern dauert wesentlich länger als sich den zeiger zusammenzuaddieren und zu -multiplizieren) und ausserdem wesentlich aufwändiger zu programmieren.
per einfacher speicherreservierung braucht man eine anweisung zum erstellen (reservieren von speicher), eine für den zugriff und eine zum speicher freigeben (nicht vergessen, zu jedem malloc/calloc/realloc gehört ein free oder realloc, sonst können speicherlücken auftreten, was zu abstürzen führen kann aber nicht muss, also ein laufzeitfehler, der schwer zu finden ist, da er nicht immer auftritt).

:edit:
hier nochmal den code:

Quellcode:
int mapwidth=256;    //natürlich können hier auch andere zahlen stehen
int mapheigth=512;

/***** feld initialisieren *****/
char * pnMap=0;

if(!(pnMap=(char*)calloc(mapwidth*mapheigth,sizeof(char))))
{
    //fehler: nicht genug speicher vom betriebssystem bereitgestellt
}

/***** arbeiten mit dem feld *****/
//...
*(pnMap+x*nHeight+y)=25;
//...
cout<<pnMap[x*mapwidth+y];
//...

/***** feld wieder aus dem speicher entfernen *****/
free(pnMap)


Entities: HL | HL²
Kompilierfehler
r_speeds | mehr über r_speeds