Ich will nenn Array aus Pointern erstellen. Allerdings ein 2-dim.. Das will ich so machen:

Block** blocks; // in Header

// in cpp Datei
blocks = new Block*[width][height];

Okay ich erhalte folgende Fehlerausgabe vom Compiler:

(gdb) make
g++ -g `pkg-config --cflags clanGL-0.7 clanDisplay-0.7 clanCore-0.7 clanApp-0.7 clanSound-0.7 clanMikMod-0.7 clanVorbis-0.7` `sdl-config --cflags` -c LevelRenderer/Level.cpp -o Level.o
LevelRenderer/Level.cpp: In constructor `Level::Level(int, int)':
LevelRenderer/Level.cpp:12: error: cannot convert `Block* (*)[((height - 1) +
   1)]' to `Block**' in assignment
make: *** [Level.o] Fehler 1

Wenn ich es so mache dann klappts:

blocks = new Block*[width * height]

Was ist beim ersten falsch denn ich kann mit der Compilermeldung nix anfangen.

mfg
Tojm

Hi !

Ich will nenn Array aus Pointern erstellen. Allerdings ein 2-dim.. Das will ich so machen:

Block** blocks; // in Header

// in cpp Datei
blocks = new Block*[width][height];

Du kannst wenn du ein Array auf dem Heap anlegst maximal *eine* Dimension angeben. (Wenn du ein Array auf dem Stack anlegst, kannst du nur mehrere Dimensionen angeben, sofern diese zur compile-time bekannt sind. Desweiteren kannst du bei auf dem Stack erzeugten Arrays die Dimension, die am weitesten links steht, weglassen bzw. musst sie nicht angeben)
Um ein 2D-Array aus Zeigern auf Block dynamisch anzulegen, kannst du es so machen:

Block*** blocks = new Block**[width]; // 1. Dimension.
for(size_t i = 0; i < width; ++i)
    blocks[i] = new Block*[height]; // 2. Dimension.

Jetzt kannst du Adressen in diesem 2d-Vektor abspeichern. Z.B. wenn x < width && y < height ist folgender Code legal:

Block my_block;
blocks[x][y] = &my_block;

/edit: Trotzdem ist es hier imho angebracht über Alternativen nachzudenken (z.B. std::vector<std::vector<Block*> >).

Caipi

Wie Du siehst hab ich schon vectoren benutzt. Allerdings habe ich dadurch starke Geschwindigkeitseinbußen. Mittels einen 2dim Arrays aus Pointer kann ich das ganze sehr viel schneller machen. Allerdings verstehe ich nicht warum ich in null_level_blocks() einen sigmentation fault erhalte.

Und zwar, wenn man einen solchen 2 Dimensionalen Array wieder freigeben will, macht man das nun für jedes Element einzeln:

unsigned int i = 0;
for (i = 0; i < anzahlElemente; i++)
    delete blocks[i];

oder mit dem Array Operator (oder wie das auch immer heissen mag):

delete[] blocks;

Wann benutz ich was?
Irgendwie ist mir das noch nicht so klar.

MfG

Vic

Bei der Gelegenheit hätte ich auch noch ne Frage dazu.
Das betrifft die Freigabe des Speichers.

Und zwar, wenn man einen solchen 2 Dimensionalen Array wieder freigeben will, macht man das nun für jedes Element einzeln:

unsigned int i = 0;
for (i = 0; i < anzahlElemente; i++)
    delete blocks;

oder mit dem Array Operator (oder wie das auch immer heissen mag):

delete[] blocks;

Wann benutz ich was?
Irgendwie ist mir das noch nicht so klar.

MfG

Vic*

Beide Varianten sind hier falsch.

Grundsätzliches:
Wenn du einen Speicherbereich mit [i]new* anforderst musst du ihn mit delete wieder freigeben. Wenn du dagegen einen Speicherbereich mit new[] anforderst musst du ihn mit delete[] freigeben.

Bei einer Reservierung der folgenden Art:

Block*** blocks = new Block**[width]; // Speicher mit new[] angefordert. (1. Dimension)
for(size_t i = 0; i < width; ++i)
    blocks[i] = new Block*[height]; // Speicher wird mit new[] angefordert (2. Dimension)

gibst du ihn wie folgt frei:

for(size_t i = 0; i < width; ++i)
    delete[] blocks[i]; // Speicher wird mit delete[] freigeben (2.Dimension)
delete[] blocks; // Speicher mit delete[] freigeben (1. Dimension)

Für jedes new[] in der entsprechenden Dimension rufst du das delete[] auch wieder auf.

Caipi

kann mir jemand sagen wie ich aus einem

char tmp[256];

ein

char tmp[13];

mache ?

Danke, Lilo