Array aus Pointer

TomDaHomm

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];

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

Caipi

TomDaHomm schrieb:

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

#include "Level.h"

Level::Level( int WIDTH , int HEIGHT ) {

    int width = WIDTH;
    int height = HEIGHT;

    basicBlocks = new vector<Block*>();
    level_blocks = new vector<Block*>();
    enemies = new vector<Enemy*>();

    //in Header siehts so aus: Block*** blocks;
    blocks = new Block**[height];
    for( int j = 0 ; j < height ; ++j ) 
        blocks[j] = new Block*[width];

    null_level_blocks();
}

void Level::set_size( int WIDTH , int HEIGHT ) {

    width = WIDTH;
    height = HEIGHT;

}

void Level::null_level_blocks() {

    for( int i = 0 ; i < height ; ++i )
        for( int j = 0 ; j < width ; ++j )
            blocks[i][j] = 0;

}

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.

_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[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

ach verdammt ich ab width und height vertauscht. Alles klar jetzt klapps

Caipi

Vic schrieb:

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

groovemaster

Hatten wir doch erst letztens
http://www.c-plusplus.net/forum/viewtopic-var-t-is-121040.html

Hiho !

kann mir jemand sagen wie ich aus einem

char tmp[256];

ein

char tmp[13];

mache ?

Danke, Lilo

c.rackwitz

nein.

groovemaster

Sowas geht nicht, ist aber auch unnötig. Wozu willst du denn das Array verkleinern, 13 Zeichen Platz hast du auch im ursprünglichen Array.