dynamisches zweidimensionals array

ross

Mit folgenden Code erzeuge ich ein zweidimensionales Array. Dabei ist Max_S einen Konstante und AnzahlZeilen eine Variable. Ich möchte aber dieses Array mit zwei Variablen AnzahlZeilen und AnzahlSpalten erzeugen. Wenn ich Max_S durch die Variable AnzahlSpalten ersetze, erhalte ich lauter Fehlermeldungen.
Ich benutze Visual C++6 und schreibe eine Win32-Konsolenanwendung.

double (*testarray) [Max_S] = new double [AnzahlZeilen][Max_S];
delete [] testarray;

Vielen Dank für die Hilfe

Con*n

Hi,

wenn Du so was wie ein zweidimensionales Array dynamisch erstellen willst, dann so:

double **wert = new double*[AnzahlZeilen];
    for (int i=0 ; i<=x ; i++)
        wert[i] = new double[AnzahlSpalten];

Das ist zwar nicht wirklich ein zweidimensionales Array auf double, sondern ein Zeigerarray auf Zeiger, aber mit wert[3][4] kommst Du trozdem in einen von Dir reservierten Speicherbereich, in dem Du Werte speichern kannst. Ein 'simuliertes' zweidimensionales dynamisch erzeugtes Array also.

grüße Con@n

[ Dieser Beitrag wurde am 15.06.2003 um 22:04 Uhr von Con@n editiert. ]

[ Dieser Beitrag wurde am 16.06.2003 um 08:54 Uhr von Con@n editiert. ]

UncleSniper

Ich will ja nicht unken, aber es wird doch nicht garantiert, dass die in der Schleife allozierten Arrays im Speicher "hintereinander" liegen. Der Compiler geht ja bei einem Zugriff via testarray[1][2] davon aus, dass testarray = malloc(AnzahlZeilen * AnzahlSpalten) ist, dass der allozierte Speicher praktisch "als Block" vorliegt. Daher kann das ganze bei einem Zugriff à la testarray[1][2] zu Segmentation Faults führen... (Ich hoffe, ich habe das jetzt verständlich rübergebracht...)

$cat >foo.cpp
int main() {
  double **wert = new double*[5];
  int i;
  for(i = 0; i < 5; ++i)
    wert[i] = new double[8];
  wert[3][3] = 0;
  return 0;
}
^D
$g++ foo.cpp
$./a.out
Segmentation fault
$

(Nicht dass ich's ausprobiert hätte -- alles rein hypothetisch.)

Bashar

Vielleicht hättest du's ausprobieren sollen

Der Compiler geht bei wert[a][b] eben nicht von einem großen zusammenhängenden Block aus. Er wendet stupide die Regeln für den [] Operator an.

wert ist ein double**
dann ist wert[a] ein double*, nämlich der an der Adresse *(wert + a).
dann ist wert[a][b] ein double, nämlich das an der Adresse ((wert + a) + b)

Blue-Tiger

was bewirkt ein Syntax wie:

int (*pArr)[5] = 0;

eigentlich?

Bashar

das definiert einen Pointer auf ein Array von 5 int-Elementen und initialisiert ihn mit dem Nullzeiger.

Blue-Tiger

und warum schreibt man dann nicht gleich

int** foo = 0

macht ja keinen Unterschied (oder?), ist aber uebersichtlicher, IMO

Bashar

Es macht aber einen Unterschied. Ein Array ist ein Array und ein Pointer ist ein Pointer. Am einfachsten wird es plausibel, wenn man sich die Repräsentation im Speicher anguckt.

int (*p)[5];
int **q;

da wo p hinzeigt, liegen hintereinander 5 ints.
da wo q hinzeigt, liegt die Adresse eines ints.

Blue-Tiger

dachte immer Arrays und Pointer sind in C/C++ absolut kein Unterschied... *g* man lernt eben doch nie aus... ^^

EDIT: wann macht dieser Unterschied denn was aus?

[ Dieser Beitrag wurde am 16.06.2003 um 14:06 Uhr von Blue-Tiger editiert. ]

UncleSniper

Der Compiler geht bei wert[a][b] eben nicht von einem großen zusammenhängenden Block aus. Er wendet stupide die Regeln für den [] Operator an.

wert ist ein double**
dann ist wert[a] ein double*, nämlich der an der Adresse *(wert + a).
dann ist wert[a][b] ein double, nämlich das an der Adresse ((wert + a) + b)

Momentchen...
foo[a][b] ist Syntactic Sugar für ((foo+a*sizeof(foo))+b*sizeof(foo)). *vergleicht* Du hast recht. Da hab ich wohl etwas vorschnell gepostet.