Hi,
hoffentlich kommt die Lösung nicht zu spät...
Dein eigentliches Problem besteht darin, dass du zur Zeit des Kompilierens noch keine Aussage darüber treffen kannst,
wie groß dein 2D-Array sein muss, welches deine Matrix repräsentiert.
Aber kein Problem, denn dafür gibt es die Funktion "malloc". Diese kann dir zur Laufzeit Speicher reservieren, auf den du lesenden und schreibenden Zugriff hast.
Eine Referenz zum Nachlesen:
malloc Dokumentation
Die Funktion erwartet als Argument einen Zahlenwert, wie viel Bytes sie für dich reservieren (allokieren) soll. In der Doku steht etwas vom Typ size_t, aber das ist nur eine Typdefinition auf einen Integer bzw. unsigned Integer. Man kann also einfach Ganzzahlen reinschreiben. (diese werden auch von der Funktion sizeof() zurückgegeben)
Im weiteren gehe ich einfach mal davon aus, dass du nur Integer-Werte (ganze Zahlen) in der Matrix speichern willst.
Jede Zelle deiner Matrix wird also mit einem Integer-Wert belegt. Ein solcher Wert benötigt natürlich einen gewissen Speicherplatz.
Wir brauchen also Platz für Zeilen * Spalten.
Ein kleines Beispiel dazu:
Angenommen du hast eine Matrix mit 5 Zeilen und 4 Spalten. Diese Matrix kann Integer-Werte aufnehmen. Ein solcher Integer-Wert benötigt entweder 2 oder 4 Byte an Speicher (2, wenn du auch negative Werte erlauben willst und 4, wenn es nur positive sein sollen).
Wir haben also 5 * 4 = 20 Zellen, die jeweils 2 Byte Speicher brauchen. Insgesamt benötigen wir also 40 Byte Platz im RAM.
Mit malloc wäre das wie folgt möglich:
Oder allgemeiner:
Code:
... = malloc(AnzahlZeilen * AnzahlSpalten * sizeof(int));
Auf dein Problem umgemünzt:
Also, was wir jetzt machen, ist ein 2D-Array mit ausreichend Speicher zu reservieren, sodass deine eingegebenen Werte da rein passen:
Schritt 1.)
Wir machen uns klar, dass die C-Schreibweise int meinArrayName[][] hier nicht funktioniert, da dafür zur Zeit des Kompilierens dessen Größe in den eckigen Klammern festgehalten werden muss. Wir wissen aber nicht, was der Anwender eingibt...
Schritt 2.)
Wir legen das 2D-Array in abenteuerlicher Pointer-Schreibweise an:
Schritt 3.)
Wir werden jetzt genügend Speicher für die Anzahl der Spalten reservieren lassen (mit der oben angesprochenen Funktion malloc())
Code:
matrix = (int**)malloc(sizeof(int*)*nAZeilen);
Schritt 4.)
Jetzt reservieren wir pro Zeile noch Platz für eine entsprechende Anzahl an Spalten.
Code:
for(int row=0; row<nAZeilen; row++) {
matrix[row] = (int*)malloc(sizeof(int)*nASpalten);
}
Schritt 5.)
Wir sehen, dass wir nun wie auf ein ganz gewöhnliches 2D-Array zugreifen können und nutzen das innerhalb der beiden for-Schleifen aus. Du kannst demnach einen vom Nutzer eingegebenen Wert wie folgt in die Matrix schreiben lassen:
Code:
for(int row = 0; row < nAZeilen; row++) {
for(int col = 0; col < nASpalten; col++) {
printf("Element A%d,%d: ", row, col);
scanf("%d", &matrix[row][col]);
}
}
Schritt 6.)
Wir wollen nach der ganzen Eingabe-Geschichte natürlich wissen, wie die Matrix nun aussieht. Also noch eine kleine Funktion gebastelt, die dir die Matrix ausgibt.
Code:
void printMatrix(int** matrix, int rows, int cols) {
for(int _row = 0; _row < rows; _row++) {
for(int _col = 0; _col < cols; _col++) {
printf("%d ", matrix[_row][_col]);
if(_col == (cols-1))
printf("\n");
}
}
}
Die kannst du einfach folgendermaßen aufrufen:
Code:
printMatrix(matrix, nAZeilen, nASpalten);
Das war es eigentlich auch schon. Du hast somit zur Laufzeit des Programms die Größe eines 2D-Arrays festgelegt und entsprechend Speicher reserviert. Das Array anschließend vom Anwender mit Werten füllen lassen.
Hinweis:
Die Speicher-Reservierung ist momentan nur für Integer-Werte ausgelegt, d.h. dort können auch nur Integer-Werte gespeichert werden. Möchte man das flexibel gestalten, so könnte man mit einem Template / Generics arbeiten.
Dein Code-Fragment sieht mir jedoch schwer nach C aus und da sollte es die Möglichkeit leider nicht geben.
Ich hoffe, dass dir das zumindest ein wenig geholfen hat.
Viel Spaß beim Probieren und noch einen schönen Abend...
