2D-Array in Klasse erzeugen

Computer: Software & Programmierung C/C++
#1

Hi,

ich bastel mir eine eigene Klasse. Im Konstruktor werden zwei Werte (int) übergeben, mit denen ich dann einen 2D-Array erzeugen will. Leider bekomme ich das nicht hin.

Bei einem einfachen Array kann ich es über einen Pointer
realisieren.

Bsp.

public:
…Test(int i, int j) {
int *_test = new int[j]; // so gehts.
int _test[j]; // so nicht

int *_test = new int[i][j]; // so auch nicht
}
private:
int *_test;

Ich bekomme dann immer einen Error, dass ich einen konstanten Wert brauche, und ich einen reinterpret_cast machen soll. Der hat aber auch nichts gebracht.

Also meine Frage: Wie kann ich das Problem lösen? Ist ein Pointer
auf einen Array besser oder ein normaler Array, da man ja auch mit einem Pointer auf Array jeden einzelnen Wert ansprechen kann?

Vielen vielen Dank
Torsten

#2

Du kannst kein „statisches Array“ anlegen, wenn der Speicherbedarf dem Compiler nicht bekannt ist. Diesen errechnet der Compiler anhand der angegebenen Elemente und dem Speicherbedarf (Typ) jedes Elementes. Aus diesem Grund musst Du Konstanten fuer das Array angeben.

In der klassen-Deklaration kannst Du es wie folgt machen:

enum {
MAX_ELEMS 100
};

int m_aryText[MAX_ELEMS];

Reinterpretiert wird hier nix. reinterpret_cast ist mit Vorsicht zu geniessen und zeugt immer von schlechtem Programmierstil. Ich empfehle reinterpret_cast nur in der COM-Programmierung.
Wenn dann vielleit dynamic_cast, denn dieser cast liefert einen NULL-Pointer (bei pointer-Cast) wenn der Cast schief geht und eine Exception vom Typ bad_cast, wenn der referenz-Cast schief geht. Beides kann man gut zur Laufzeit testen (auf NULL pruefen) oder try-catch (bei Referenzen).

Des weiteren gibt der new-Operator schon den richtigen Pointer-Typ zurueck.

Du musst Dein 2dim Array auf dem heap anlegen. z.B. so:

int (*z)[4] = new int [x][4];

x kann dabei variable sein. Diese 2dim Array ist im Speicher ja linearisiert sozusagen und z zeigt auf den Anfang des Arrays, dessen erstes Element widerum ein 4-elementiges int-Array darstellt. Wenn Du Pointer-Arithmetik macht, z.B. z+1, dann
wandert der pointer nicht im 4 bytes weiter (pro sizeof(int)), sondern um 4x4 Bytes weiter, all die weil ein Element des Arrays auf 2. Ebene eben 4 ints darstellen.
Aus diesem Grund kann x variable sein, aber nicht der Wert 4.

Oder z.B.:

float (*d)[4][5] = new float[y][4][5];

d ist dabei nicht ein Pointer auf ein float, sondern ein pointer aus 4*5 floats. Entfernen geht dann via:

delete [] d;

Wichtig ist oben auch

int (*z)[4] = …

und nicht z.B.:

int *z[4] = …

Denn dies waere ein 4-elementiges Array, dessen Elemente vom Typ Pointer auf int sind; was definitiv was anderes ist.

CU

#3

OK, danke,

durch Deine Erläuterungen scheine ich
festgestellt zu haben, dass ich auf diese Weise
gar keine mehrdimensionalen dynamischen Arrays
erzeugen kann, oder liege ich da falsch?

Also bleibt mir nichts anderes übrig, als
direkt mit der Pointermanipulation zu
arbeiten.

Für einen dyn. 2D-Array mit den Dimensionen
x und y würde ich dann einfach so arbeiten:
Ich initialisiere ich einen 1D-Array:

int *A = new int[x*y];

Jede einzelne Speicherstelle addressiere
ich so:
Ich teile meinen Array in x Blöcke auf.
i adressiert einen Block, und j
ist mein Blockoffset (im Grunde so ähnlich wie
beim Speicher, oder genauso)

*(A+y*i+j) = …

i darf aber immer nur um die größe des Blocks
wachsen und nicht um 1. Deshalb wird i mit
der Anzahl an Aufteilungen eines Blocks, also y
multipliziert.
Und sieh mal einer guck: Ich habe einen
dynamischen 2D-Array.

Torsten

#4

Moin, Moin!

durch Deine Erläuterungen scheine ich
festgestellt zu haben, dass ich auf diese Weise
gar keine mehrdimensionalen dynamischen Arrays
erzeugen kann, oder liege ich da falsch?

Ich glaube da liegst du falsch, denn folgendes funktioniert:
class Test_C
{
public:
Cac_C(int x, int y); //Konstruktor
~Cac_C(); //Dekonstruktor
private:
int **Matrix; //Dynamisches 2D Array
int nx;
int ny;
};

Test_C::Test_C( int x, int y)
{
int i;
nx = x;
ny = y
Matrix = new int*[x];
for(i=0; i

1 Like
#5

Hi,

ja, auf diese Weise geht es auch.
Aber es ist ein bisschen umständlicher
als das, was ich mit der
Pointermanipulation beschrieben habe.

Torsten