Aufgabe Matrix

muma1300

Grünschnabel
Hi,

ich hoffe es kann mir jemand bei meinem Problem helfen.

Ich will eine Matrix abfragen und der Benutzer soll bestimmen wie viel Zeilen und Spalten diese Matrix hat.
Er wird gefragt:
Zeilen der Matrix:
Spalten der Matrix:

So weit hab ich das schon. Und jetzt zu meinem Problem:

Gibt er z.B ein, dass die Matrix A eine 3x3 Matrix sei, dann soll er die einzelnen Werte in dieser Matrix eintippen wie folgt:

A0,0=
A0,1=
A0,2=
A1,0=
A1,1=
A1,2=
A2,0=
A2,1=
A2,2=

Wie setze ich das um?

Es kann ja auch sein, dass der Benutzer eine 4x3 oder 5x5-Matrix haben möchte.Dann werden es ja dementsprechend mehr Werte.
Mit den einzelnen Werten soll dann später mit anderen Matrizen weitergerechnet werden.

Vielen Dank für euer Bemühen :)
 

muma1300

Grünschnabel
printf("Matrix A Zeilen: ");
scanf("%d",&nAZeilen);
printf("Matrix A Spalten: ");
scanf("%d",&nASpalten);
printf("\n");

for(i=0;i<nAZeilen;i=i+1)
{
for(j=0;j<nASpalten;j=j+1)
{
printf("Element A%d,%d: ",i,j);
scanf("%d",****?);
printf("\n");

was muss anstelle der Fragezeichen hin? Damit ich später mit dieser Matrix noch weiterrechnen kann ?
 

Alex_T

Erfahrenes Mitglied
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:

Code:
... = malloc(40);

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:
Code:
int** matrix

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...
 

Neue Beiträge