Dynamische Array Zeiger Tabelle

[DuffCola]

Hallo.
Ich habe jetzt, nachdem ich eine Zeit lang kein C++ mehr gemacht habe(Habe etwas C# und Java gemacht), meine C++ wieder Kenntnisse etwas aufgefrischt.
Jetzt habe ich das Buch C++ von A-Z angefangen nochmal zu wiederholen.
Jetzt habe ich aber im Buch etwas nicht wirklich verstanden.
Und zwar ist mir im follgenden Code nicht alles kla(Hier wird eine Dynamische Tabelle mit eine Zweidimensionalen Zeiger erstellt):

#include <iostream>

using namespace std;

int main(void)
{
	// Die Variablen
	const int zeilen = 25;
	const int spalten = 50;
	int **tabelle; // Der Zweidimensionale Zeiger

	// Dynamische erstellung dr Tabelle
	tabelle = new int*[zeilen]; // Hierbin ich mir unsicher was das Sterchen hier bedeutet
								// Erstellte der hier bei der ersten Zeiger Diemension eine Array, dass jenachdem 
								// wieviele Zeilen erstellt werden sollen ein Array, dass die adressen der Spalten Arrays     speichert?
	for(int zeile = 0; zeile < zeilen; zeile++)
	{
		tabelle[zeile] = new int[spalten]; // Erstellt der jetzt für jeden Zeiger im Array ein Array, dass die eigentlichen Werte darstellt?
	}

	// Initalisierung der Tabellen Werte
	for(int zeile = 0; zeile < zeilen; zeile++)
	{
		for(int spalte = 0; spalte < spalten; spalte++)
		{
			tabelle[zeile][spalte] = 0; // Hier wird in er ersten Klammer die erste Zeiger diemension angesprochen und dann in der
										// Zweite Klammer die Zweite Dimension
		}
	}

	// Ausgabe in der Console
	for(int zeile = 0; zeile < zeilen; zeile++)
	{
		for(int spalte = 0; spalte < spalten; spalte++)
		{
			cout<<tabelle[zeile][spalte]; // Dasselbe wie eben
		}
		cout<<'\n';
	}

	// Löschen der Tabelle
	for(int zeile = 0; zeile < zeilen; zeile++)
	{
		delete [] tabelle[zeile]; // Hier werden von jeder Zeile die dass Spalten Array, dass die eigentlichen Tabellen Werte speichert gelöscht
	}
	delete [] tabelle; // Hier wird das Zeilen Array, das die Zeiger der Spalten hatte gelöscht

	cin.get(); // Auf ein Enter warten
	return 0; // Return mit 0
}

Ich hoffe jemand kann meine Aussagen in dem Quellcode korrigieren, weiter erklären oder bestätigen.

 

[sheel]

Hi

ich geh davon aus, dass dynamische eindimensionale Arrays halbwegs klar sind.

Zu Zeile 10 (und Allgemeines):
Genau, ein zweidim. Zeiger. Bedeutet mal nicht viel weiteres.

Kurzer Abstecher zu den eindim.:
Sowas wie int* float* char* sind alles Variablen für Speicheradressen,
in jedem Fall int (auch float* ist praktisch ein int usw., Adressen sind ja immer ganzzahlig)
Der Typ gibt nur an, was sich für eine Variablenart an dieser Adresse befindet.
(Dazu gibts noch die Sache mit & und * zuzugreifen, das macht Pointer ja erst nützlich)

Ein float* ist also ein int, und an der durch den Wert festgelegten Adresse ist ein float
Ein int** ist auch nur ein int, und an der gezeigten Adresse ist ein int*
Dieses hat wiederum eine Adresse, auf ein wirkliches int.
Mehr ist da nicht dahinter.

Nehme an, die (eindim.) Sache mit dem Zugriff per [...] ist auch klar.
*x oder x[0] zeigen beide auf das eigentliche int an der Adresse.
Es können aber auch viele in einer Reihe sein, mit x[1], x[2]...
bekommt man die ints an den nächsten Speicherstellen
(selbes wie *(x+1*4), *(x+2*4) vorausgesetzt int ist 4 Byte groß)

Zeile 13:
Ein zweidim. Array kann man praktisch als Array aus eindim. realisieren.
Es gibt einen Pointer tabelle, zeigt auf nichts

tabelle->?

So, wie man bei einem eindim. float* ein float-Array anlegen könnte,
wird hier jetzt ein Array aus int-Pointern angelegt
(die wiederum jeder ein Arrayaus int´s "aufnehmen" können)
Um ein Array ausnahmsweise untereinander statt nebeneinander zu schreiben:

tabelle
 |pointer->?
 |pointer->?
 |pointer->?
 |pointer->?
 |pointer->?
...

In der for-Schleife ab Zeile 16 gehst du jetzt jeden Pointer in tabelle durch
und legst dafür ein Array an.

tabelle
 |pointer->int int int int int int int
 |pointer->int int int int int int int
 |pointer->int int int int int int int
 |pointer->int int int int int int int
 |pointer->int int int int int int int
...

In die Elemente können jetzt wirklich normale Zahlen gespeichert werden
(na gut, kann man in Pointer auch, aber geht am Sinn vorbei)

Die "Zeilen", also Pointerelemente vom Array tabelle,
könnten theoretisch verschieden lange Arrays haben.

tabelle
 |pointer->int int int
 |pointer->int int int int int int int int int
 |pointer->int int int int int
...

Du legst in der for-Schleife eben immer die gleiche Länge an.
(Bei verschiedenen Längen muss man auch irgendwo wissen, wie lang welche Zeile ist)

Zugriff auf Elemente in Zeile 26
geht im Prinzip wie bei eindim. Arrays.
Tabelle mit seinen Unterpointern ist nichts Anderes als ein eindim. Array aus int´s,
nur die int´s haben seltsame Werte (Adressen eben)
Mit dem ersten [] sucht man sich eben einen der Pointer im Array Tabelle aus
(die "Zeile" oben). Danach hat man den Pointer auf ein weiteres Array da
und holt sich mit dem zweiten [] eines der int´s daraus.

Und zum Löschen noch ab Zeile 42:
Genau. Zuerst werden alle Pointer aus tabelle durchgegangen und deren Arrays gelöscht,
und am Schluss wird noch das Array tabelle gelöscht.