# [c++] Mehrdimensionales Array



## WhiteNazgul (17. November 2003)

*new-Mehdimensionales Array*

Hi!

Leider lassen es meine Kenntnisse derzeit noch nicht zu das folgende Problem selber zu meisternDie MSDN war auch nicht ergiebig)
Mittels new soll ein Mehrdimensionales Array initialisiert werden.

```
float *pnewarray=0;
pnewarray=new float pnewarray[x][y];
```

Leider lässt es der Compiler nicht zu, meine Frage: Ist es überhaupt möglich Mehrdemsionale Arrays dynamisch erstellen zu lassen? Wenn ja, wie 

Vielen Dank für die mögliche Antwort im vorraus.


----------



## rockbaer (18. November 2003)

pnewarray = new float [x * y];

oder

float (*pnewarray)[y]  = new float [x][y];


----------



## WhiteNazgul (18. November 2003)

Habe dank, nur würde
pnewarray[x*y] ein eindimensionales Array mit x*y Elementen erzeugen.

Bei der zweiten Möglichkeit setzt du vorraus, das eine unbekannte, in diesem Fall y bekannt ist. Beide x,y sind allerdings Unbekannte, die zur runtime erst ermittelt werden.


----------



## chibisuke (18. November 2003)

worüber dein compiler meckert ist das ein multidimendionales array über einen pointer mit n ebenen addressiert werden muss wobei n die anzahl der dimensionen ist... wenn du also ein 2 dimensionales array hasst muss du float** benutzen
des weiteren ist der syntax für new garantiert nicht
new float pnewarray[x];
sondern wenn schon dann new float[x];

multidimensionale arrays müssen in mehreren schritten entsprechend den ebenen erstellt werden.. das sieht dann so aus:


```
float** myarray = new float*[x];
for(int i = 0; i < x; i++) {
    myarray[x] = new float[y];
}
```

und gelöscht wird es mit

```
for(int i = 0; i < x; i++) {
    delete[] myarray[x];
}
delete[] myarray;
```


----------



## WhiteNazgul (18. November 2003)

Habe vielen Dank für die präzise und schnelle Antwort, und das super Beispiel.

PS:Und ja ich meinte eigentlich pnewarray=new int[x].


----------



## rockbaer (18. November 2003)

> _Original geschrieben von WhiteNazgul _
> *Bei der zweiten Möglichkeit setzt du vorraus, das eine unbekannte, in diesem Fall y bekannt ist. Beide x,y sind allerdings Unbekannte, die zur runtime erst ermittelt werden. *



Natzgul, wenn du in c++ codest  (Was ja der fall ist) kannst du dein 2dimensionales Array mit:

float (*pnewarray)[y] = new float [x][y];

auch erst ( "zur runtime" wie du sagst) erstellen wenn du x und y ermittelt hast, beide (x und y) können also unbekannt sein


----------



## BLR (11. September 2014)

Hallo zusammen,
ich sitze gerade an dem selben Problem und dieses Beispiel ist super.
Allerdings verstehe ich nicht ganz genau, was da passiert:

Ein doppelter Zeiger bedeutet, dass die Speicheradresse A, die Speicheradresse von B hat.
Speicheradresse B hat die Speicheradresse von C und C hat den eignetlichen Wert.


```
float** myarray = new float*[x];  //was passiert genau auf der rechten Seite im Speicher?
                                                    //"new" gibt einen Zeiger zurück
                                                   // und was macht der  Ausdruck float*[x] und warum ist das notwendig für einen
                                                  // float** ???
for(int i = 0; i < x; i++) {
    myarray[x] = new float[y];
}
```


P.S ich habe noch nie mit doppelten Zeigern gearbeitet.
Danke


----------



## Jennesta (11. September 2014)

Hallo BLR,

Im Prinzip passiert da folgendes. Du möchtest eine 2-dimensionale Struktur erzeugen, Hier kannst du dir einfach eine x mal y große Matrix vorstellen. 

Mit der Zeile 

```
float** myarray = new float*[x];
```
erzeugst du quasi x mal Zeiger auf float* als Array. Im Beispiel der Matrix würde dieses Array nun alle Adressen in deiner Matrix enthalten, die auf eine neue Zeile zeigen.

Mit den weiteren Zeilen:

```
for(int i = 0; i < x; i++) {
    myarray[x] = new float[y];
}
```

erzeugst du für jede Zeile y Spalten in der Matrix, die mit einem float Wert belegt werden können. Vorstellen kannst du dir das also wirklich wie eine Matrix, wo du zwei Informationen brauchst um auf eine Zelle zu kommen. Nämlich die einer Zeile und einer Splate. In dem Beispiel ist das halt mit Zeigern, wobei zuerst in dem Array mit den Speicheradressen gesucht wird und danach in dem Array der Wert.

Viele Grüße,
Jennesta


----------



## BLR (11. September 2014)

Hallo,
danke für deine schnelle Antwort. Die zweite Erklärung hab ich verstanden, allerdings bin ich mir bei der ersten unsicher

Diese Zeile:


```
float** myarray = new float*[x];
```

Was passiert genau auf der rechten Seite der Zuweisung`?

>>erzeugst du quasi x mal Zeiger auf float* als Array

Verstehe ich nicht...
wenn x = 3 ist, dann habe ich 3 float-Zeiger?
Falls ja, werden dann diese 3 float-Zeiger durch das Wort new erzeugt?
Falls ja, habe ich ja erstmal nur einen Zeiger( entweder 1,2 oder 3) hier gibts aber doppelten Zeiger.
Wie funktioniert das^^


----------



## Jennesta (11. September 2014)

Hallo,

einmal ganz grundsätzlich zum Speicher. Mit new wird in einem Programm Speicher dynamisch zur Verfügung gestellt. D.h im Gegensatz zu Arrays, die folgendermaßen erzeugt werden:

```
int arr[3];
```
liegen Arrays die dynamsich erzeugt werden:

```
int *arr = new int[3];
```
in einem anderen Speicherbereich. Hier muss der Benutzer aber auch selbst dafür Sorge tragen, dass dieser (mit delete) wieder freigegeben wird.

Das Beispiel oben ist im Prinzip eine Fortsetzung von dem zweiten Beispiel hier. Nur anstatt einen Zeiger auf das erste von 3 ints zu bekommen, bekommt man einen Zeiger auf einen weiteren Speicherbereich der ints enthalten kann. Das muss man mit dem Prozedere in der for-Schleife noch genauer spezifizieren.
Vorteil ist hier z.B. auch das man nicht den kompletten Speicher für die Matrix direkt bereitstellen muss. Es könnte auch möglich sein jedem Zeilenvektor ein Array zu geben, dass eine variable Anzahl von Elementen hat, 1 oder 100 oder ...


----------



## BLR (11. September 2014)

Hallo 

Danke für die Erklärung.
Das interessante (und für mich neue) ist, dass man anstatt (wie du beschrieben hast)
mit:
new int[3] 
den Speicherbereich für 3 Int´s reserviert, schreibt man:
(original waren es: new float*[x]

new int*[3]; 
Wozu schreibt man den Punkt noch dahin?


----------



## ComFreek (11. September 2014)

new int*[3] reserviert Speicher für drei Zeiger, die jeweils auf einen int zeigen.
Mit new int[3] reservierst du Speicher für drei int-Werte.


----------



## BLR (11. September 2014)

ahh das ist einfach ein int-zeiger array?
sprich, ich habe 3 neue Speicherbereiche für int-zeiger im Heap reserviert.


----------



## sheel (12. September 2014)

Genau.
Und jeder dieser drei int-Zeiger kann eben wieder die Adresse für ein Array aus ints speichern.


----------

