Mehrdimensionales Array code unklar

[helpme91 (Gast)]

Hallo zusammen,

ich bin gerade dabei, in C++ ein zwei Dimensionales Array zu erstellen 
mit Pointern. Der Benutzer soll die größe festlegen können.

Ich habe folgendes bis jetzt gemacht:

int zeilen = 0;
int spalten = 0;

// Einlesen der Zeilen und Spalten:
..... (das schreibe ich jetzt nicht extra auf.)

// 2D - Array erzeugen:
  
  int** twoDimArray = new int* [zeilen]; // Pointer - Array

  for (int i = 0; i < Zeilen; i++){
    twoDimArray[i] = new int[spalten];
  }

Es scheint zu funktionieren, aber so wirklich verstanden habe ich es 
nicht.
Kann man das so machen?

SG

[Andras H. (kyrk)]

Hallo,

int** twoDimArray = new int* [zeilen];
ich bin kein Experte, aber ich meine, das kann zwar funktionieren, aber 
es ist nicht unbedingt richtig. Der Compiler weiß vermutlich von 
twoDimArray nicht dass es eigentlich ein pointer auf arrays von ints 
ist. Zum Glück ist der Pointer genau so groß. Macht kein unterschied. 
Wobei später könnte es probleme machen.

[helpme91 (Gast)]

Wie wäre es dann richtig?

[mikroBe (Gast)]

helpme91 schrieb:
> Wie wäre es dann richtig?

Das ist schon vollkommen richtig so.
Ein Pointer auf ein Array ist immer nur ein Pointer auf das erste 
Element des Arrays. Zumindest nach der Initialisierung - wenn man ihn 
hochzählt, natürlich nicht mehr.

[helpme91 (Gast)]

Dann stimmt mein Code so?

Ich weiß nicht, ob ich int Zeilen und int Spalten richtig im Code 
eingesetzt habe?

[mikroBe (Gast)]

helpme91 schrieb:
> Dann stimmt mein Code so?
>
> Ich weiß nicht, ob ich int Zeilen und int Spalten richtig im Code
> eingesetzt habe?

Du kannst ja mal ein paar Werte in Dein Array schreiben und anschließend 
ausgeben, z.B.:

#include <iostream>

using namespace std;

int main()
{

    int zeilen = 5;
    int spalten = 10;

    int **twoDimArray;

    twoDimArray = new int*[zeilen];
    for(int i=0; i<zeilen; i++) {
        twoDimArray[i] = new int[spalten];
        for(int j=0; j<spalten; j++) {
            twoDimArray[i][j] = i*10 + j;
        }
    }

    cout << endl;
    for(int i=0;i<zeilen;i++) {
        for(int j=0; j<spalten; j++) {
            printf("[%02d]\t", twoDimArray[i][j]);
        }
        cout << endl;
    }

    return 0;
}

[00]  [01]  [02]  [03]  [04]  [05]  [06]  [07]  [08]  [09]  
[10]  [11]  [12]  [13]  [14]  [15]  [16]  [17]  [18]  [19]  
[20]  [21]  [22]  [23]  [24]  [25]  [26]  [27]  [28]  [29]  
[30]  [31]  [32]  [33]  [34]  [35]  [36]  [37]  [38]  [39]  
[40]  [41]  [42]  [43]  [44]  [45]  [46]  [47]  [48]  [49]

Die Zehnerstelle wäre in diesem Fall quasi die Zeilennummer, die 
Einerstelle die Spaltennummer.
Dann siehst Du auch Zeilen und Spalten...

[mikroBe (Gast)]

helpme91 schrieb:
> Dann stimmt mein Code so?

Ja, mal abgesehen davon, dass Du in Deiner for-Schleife oben die 
Variable "Zeilen" verwendest (mit großem Z) und darüber "zeilen" 
deklariert hast (mit kleinem z).
Aber das dürfte in Deinem richtigen Code ja korrekt sein, sonst hättest 
Du ja nicht testen können ;)

[mh (Gast)]

helpme91 schrieb:
> Dann stimmt mein Code so?
>
> Ich weiß nicht, ob ich int Zeilen und int Spalten richtig im Code
> eingesetzt habe?

Das kommt drauf an, was du damit vorhast und ob in deinem echten 
Quelltext die richtige Schreibweise von Zeilen/zeilen genutzt wird. Wie 
du die Arrays deallokierst hast du ach nicht gezeigt.

Ich gehe davon aus, dass du sowas (sehr stark vereinfacht) nutzen 
solltest.

template <typename T>
struct Array2d {
  Array2d(int z, int s) : zeilen(z), spalten(s), daten(z*s) {

  }

  T& operator()(int zeile, int spalte) {
    return daten[zeile*spalten+spalte];
  }

  int zeilen;
  int spalten;
  std::vector<T> daten;
};

[helpme91 (Gast)]

O.k., erstmals danke für die Hilfe.

Das funktioniert soweit auch alles.

Wasmir aber noch nicht so wirklich einleuchtet, wie werden hier die 
Zeilen und Spalten erzeugt.

Hier erzeuge ich ja nur mal ein Pointer-Array, das ist ja noch kein 
richtiges Array mit Daten:

int** twoDimArray = new int* [zeilen];

Hier geben ich ja schon mal die zeilen an, aber keine Spalten.

Die Spalten gebe ich erst hier an:

 
for (int i = 0; i < Zeilen; i++){
      twoDimArray[i] = new int[spalten];
}

Nur hier erzeuge ich ja das eigentliche Array.

Mich verwirrt das, weil ich ein klassisches Array immer nur so gemacht 
habe: array[i][j]

Kannst du mir den Code mal einfach erklären, momentan verstehe ich die 
erzeugung des Array noch nicht ganz?

Danke für die Hilfe!

[A. S. (Gast)]

helpme91 schrieb:
> Es scheint zu funktionieren,

Bei was? Wie greifst du zu?

helpme91 schrieb:
> ein zwei Dimensionales Array zu erstellen mit Pointern.

Wenn du "Array mit Pointern" meinst, dann erkläre, was Du darunter 
verstehst.

Wenn Du "Array" meinst, und die Pointer nur als Mittel zum Zweck siehst, 
.... Nein. Du erstellt kein zweidimensionalen Array von int.

Es kann aber zufällig sich so anfühlen, wenn aller Speicher nacheinander 
allokiert wird.

[Jonas B. (jibi)]

https://www.programiz.com/c-programming/c-multi-dimensional-arrays

[Dirk B. (dirkb2)]

Das ist kein 2D-Array - Ein Array in C (und das benutzt du) ist ein 
zusammenhängender Speicherbereich

Ein Pointer ist kein Array und ein Array ist kein Pointer.
Ein Array behält den Speicherplatz. Einen Pointer kann man verändern.

Der Name eines Arrays ergibt die Adresse des ersten Elements.

Name[i] ist dasselbe wie (*Name+i) (was dann auch dasselbe wie i[Name] 
ist)

Daraus solltest du die Ähnlichkeit im Zugriff von deinem 
(Doppel-)Pointer und beim (2S-)Array herleiten können.

Bei C++ nimmt man std::vector

[Oliver S. (oliverso)]

helpme91 schrieb:
> Nur hier erzeuge ich ja das eigentliche Array.
>
> Mich verwirrt das, weil ich ein klassisches Array immer nur so gemacht
> habe: array[i][j]

Deine Version erzeugt kein 2D-Array, sondern ein 1D-Array von Pointern, 
die jeweils auf einzelne 1D-Arrays mit den Werten zeigen. Diese einzelne 
Array müssen nicht hintereinander liegen, sondern können frei im 
Speicher verteilt sein, und müssen per delete wieder entsorgt werden..

array[i][j] erzeugt dagegen einen zusammenhängenden Speicherbereich, auf 
den dann mit i*Spaltenzahl+j zugegriffen wird.

Oliver