wir mussten letztens (4-5 Wochen her) Dynamische Arrays erzeugen.
mit dem new befehl. Dasselbe auch für Dynamische Mehrdimensionale Arrays.

Ich kann alles wunderbar Programmieren und hab damit ansich keine Probleme. Doch verstehe ich nicht ganz was dabei passiert/was ich mache.

Eine kleiner Code snippet wo ich das Array erzeuge

char** p = new char* [zeilen];

    for (int i = 0; i < zeilen; i++)
        p[i] = new char[reihen];

Was genau erzeug ich da? Einen Pointer der auf einen Pointer zeigt der auf ein Feld von Pointern zeigt? Und was in der For schleife Passiert versteh ich überhaupt nicht. Weiß ich da dem Array aus Pointern jeweils ein neues Array zu?

Ich hab irgendwo aufgeschnappt, das ich es mir einfach wie einen Pointer vorstellen soll der auf ein Array aus Pointern zeigt. Stimmt das?

-------------
|0,0|0,1|0,2|
|------------
|1,0|1,1|1,2|
-------------

Stattdessen habt ihr eine Art Liste von Arrays, die wild verteilt sind und auch entsprechend nicht alle gleich groß sein brauchen:

-----------------
| 0 |  1  |  2  |
-----------------
  |    |     |
  |    |---| |-------
  v        |        |
-----      v        |
|0,0|    -----      v
-----    |1,0|    -----
|0,1|    -----    |2,0|
-----             -----
|0,2|             |2,1|
-----             -----

Ein naheliegender Verdacht ist, dass euer Lehrer selber keine Ahnung hat. In C++ würde man das niemals so machen, selbst wenn es technisch möglich ist.

Ich kann alles wunderbar Programmieren und hab damit ansich keine Probleme. Doch verstehe ich nicht ganz was dabei passiert/was ich mache.

Das widerspricht sich.

char** p;

p ist ein Zeiger auf einen Zeiger auf ein char. (Noch uninitialisiert)

p = new char* [zeilen];

Hier erzeugen wir ein Array von Zeigern - p weisen wir die Adresse des ersten Zeigers zu.
Der Elementtyp des Arrays ist also nicht char (wie bei new char[...] ) sondern char* .

for (int i = 0; i < zeilen; i++)
        p[i] = new char[reihen];

Hier weisen wir jedem Zeiger in dem Array (auf das p zeigt) die Adresse eines char -Arrays mit reihen Elementen zu.

Damit kannst du durch mehrfache Indirektion auf ein multidimensionales Array zugreifen.
Wie du sicher weist, entspricht die Operation

A[B]

Einer Dereferenzierung mit (relativem) Offset:

*( A + B )

Damit gleicht

A[B][C]
*(*( A + B) + C)

Was du also tust: Um auf das Element [5][3] zuzugreifen, holst du dir erst den Zeiger auf das fünfte Array:
*(p + 5)
Und dann greifst du auf dessen drittes Element zu.
*(*(p + 5) + 3)

Code auswendig zu lernen und runterzutippen ist was anderes als zu verstehen was dabei genau passiert.

Dein naheliegender Verdacht ist leider total daneben, unser Info Prof. hat den Lehrauftrag uns C++ beizubringen und dazu gehört auch Dynamische Speicherbelegung.

Finde nicht das sich das wiederspricht.

Code auswendig zu lernen und runterzutippen ist was anderes als zu verstehen was dabei genau passiert.

Also kannst du es offensichtlich doch nicht "wunderbar Programmieren" und hast "damit ansich" doch Probleme?

Dein naheliegender Verdacht ist leider total daneben, unser Info Prof. hat den Lehrauftrag uns C++ beizubringen und dazu gehört auch Dynamische Speicherbelegung.

Erstens: Könntest du dich bitte direkter an Mitglieder ansprechen? Ich bin jetzt verwirrt, weil ich mich im letzten Absatz zuerst irgendwie angesprochen gefühlt habe.

Btw: Mach bitte keine solchen Bemerkungen. Das da oben ist zwar korrektes, also kompilierbares C++ - das ist aber auf keinen Fall, was irgendjemand jemals benutzen sollte (es gibt keinen Grund dafür).
Dynamische Speicherbelegung sollte es in C++ nur in Verbindung mit RAII geben. Dazu gibt es in der Standardbibliothek Container, Smart-Pointer und mehr. Meistens wirst du in C++ nicht mal ein new sehen.