dynamische Matrix (Array) erzeugen

Ork

Hallo,

ich möchte eine zweidimensionale Matrix = Array erzeugen, die sich aber aus dynamischen Zeilen- und Spaltenvariablen ergibt. Bisher habe ich folgendes probiert:

[Vereinfachte Bsp.-Version]

int main()

{ double *RC;
int m, n;

m = ....;
n = ....;

RC = (double malloc (m*n*sizeof(double));

RC[m][n] = ...;
printf("%lf", RC[m][n]);
getchar();
return 0;
}

Wie ihr sicherlich erkennt, kommt es hier zur Fehlermeldung, dass dieser Wert nicht als Array oder Pointer beschrieben wurden. Was muss ich denn am Quelltext ändern, damit mir das Programm den Wert in der Matrix RC bei entsprechender Zeile m und Spalte n ausgiebt?

AJ

In etwa so:

double **rc;
int m, n, i;

m = ...;
n = ...;

rc = malloc(m*sizeof(double *));

for(i=0;i<m;++i)
{
   rc[i] = malloc(n*sizeof(double));
}
...

Wurde hier aber schon ein paar mal behandelt. Schmeiß einfach mal die Suchfunktion an

Ork

Hallo AJ,

Deine Variante wollte ich bewußt umgehen. Ich müsste hier einmal Speicher allocieren für die Adresse und einmal für den Wert. Auch die Speicherfreigabe müsste ich dann wieder in zwei Schleifen packen.Ich habe in meinem Buch etwas gefunden, wo der Speicher Zeilenweise aus der Matrix belegt wird. Leider bin ich überhaupt nicht hinter die Funktionalität gestiegen und das Abtippen brachte auch keinen Nennenswerten durchblick. Vereinfacht wird dies so beschrieben:

double *RC;
int m, n;

*RC = (double*) malloc (m*n*sizeof (double));

soweit ist es noch verständlich. Dann wird plötzlich eingeführt

M[i,j] = RC[i*n + j];

Hier weird weder beschrieben, was M, i oder j ist (Variablendefinition = ?). Es wird lediglich darauf hingewiesen, dass mit RC[i*n + j] jedes beliebige Feld in einer dynamischen Matrix angesprochen und somit im Speicher hinterlegt bzw. abgefragt werden kann . Dafür gibt es ein paar Zahlenbeispiele, die logisch klingen, ich aber dank meiner begrenzten Programmierfähigkeit dann völlig ausgestiegen bin:

Werte für i, j = 0, 0 -> soll Wert RC[0] liefern (1. Matrixzeile / 1. Wert)
Werte für i, j = 0, n-1 -> soll Wert RC[n-1] liefern (1. Matrixzeile / Letzter Wert)

da im Speicher alle Werte hintereinanderstehen, sollten dann also

Werte für i, j = m-1, n-1 -> soll Wert RC[m*n-1] liefern (letzte Matrixzeile / letzter Wert)

Tja, nun krüble ich schon den ganzen Tag, wie man dies programmtechnisch umsetzen soll und mir also z.B. M[2,5] angezeigt wird. Ich kann schon langsam keine ROT-Durchgestrichene Zeilen mehr sehen.

AJ

Ok, wenn du das so haben willst, dann musst du das folgendermaßen machen:

//Speicherreservierung wie von dir ganz am Anfang gepostet

//Zugriff auf Element m=Anzahl Zeilen, n=Anzahl Spalten
i = zeile * n; //gesuchte Zeile * Anzahl der Spalten
j = spalte; //gesuchte Spalte bleibt gleich

printf("%lf", RC[i+j]);

Der Hintergrund ist, dass deine Werte im Speicher direkt hintereinanderliegen, z. B. { 1, 2, 3, 4, 5, 6 }. Wenn du nun diese Werte in Bereiche Aufteilst ("Zeilen"), dann musst du die Adresse der neuen Zeile angeben. Wenn man also die 6 Zahlen in Zeilen mit je 2 Spalten aufteilt, dann fängt deine 2. Zeile beim Offset 2 an (= index der zeile, also 1, * die Anzahl der Spalten, also 2). Deine 3. Zeile fängt dann beim Offset 4 an (= 2(index) * 2(anzahl spalten)).

Und jetzt viel Spaß

Ork

AJ,

ich hab jetzt mal ein kleines Testprogramm geschrieben, was zumindestens schonmal Fehlerfrei compieliert. Allerdings wird der Speicher noch nicht richtig zugewiesen. In der Schleife habe ich offenbar wieder etwas mit dem Zeiger verhauen. Das Testprogramm sieht wie folgt aus:

# include <stdio.h>
# include <stdlib.h>
# include <math.h>

int main()
{
double *F;
double M [4][4];
int i, j, m, n;

printf("Eingabe der Zeilenanzahl (<=4): ");
scanf("%d", &m);
printf("Eingabe der Spaltenanzahl (<=4): ");
scanf("%d", &n);

F = (double malloc (m*n*sizeof(double));

for ( i = 0; i < m; i++)
{
for ( j = 0; j < n; j++)
{
M[i][j] = i + j;
F[i+j] = M[i][j];
}
}

printf("Aus welcher Zeile moechten Sie einen Wert sich ausgeben lassen: ");
scanf("%d", &i);
printf("Welche Spalte aus dieser Zeile moechten Sie betrachten: ");
scanf("%d", &j);
printf("%lf", F[i+j]);
getchar();

return 0;
}

Eigentlich soll auch bei der Variablendefinition für derzeit M[4][4] später mal diese dynamische Variante M[m][n] ersetzt werden. Hier steigt er mir aber bis jetzt immer aus, so dass ich erstmal auf Altbewehrtes zurückgegriffen habe.

AJ

# include <stdio.h>
# include <stdlib.h>
# include <math.h>

  int main()
  {
	    double *F;
	    double M [4][4];
	    int i, j, m, n;

	    printf("Eingabe der Zeilenanzahl (<=4):	");
	    scanf("%d", &m);
	    printf("Eingabe der Spaltenanzahl (<=4):	");
	    scanf("%d", &n);

	    F = (double *) malloc (m*n*sizeof(double));

	    for ( i = 0; i < m; i++)
		        {
		            for ( j = 0; j < n; j++)
                {
			                M[i][j] = i + j;
			                F[i*n+j] = M[i][j];
                }
		        }

	    printf("Aus welcher Zeile moechten Sie einen Wert sich ausgeben lassen:	");
	    scanf("%d", &i);
	    printf("Welche Spalte aus dieser Zeile moechten Sie betrachten:	");
	    scanf("%d", &j);		
	    printf("%lf", F[i*n+j]);
	    getchar();

  return 0;
  }

Eigentlich hab ich dir doch beschrieben, dass du deine Zeile mit der Spaltenanzahl multiplizieren musst, um auf die richtige Zeile zu gelangen.

Ich hab jetzt an den zwei entsprechenden Stellen das *n gemacht.

Ork

Danke AJ,

habe es selber gerade herausgefunden und wollte meine Variante hier reineditieren. Hab auchdie Lösung mit der dynamischen Matrixstruktur herausgefunden. Weiß garnicht, warum ich mich so sehr an diese 2 Variablen F und M geklammert habe. Wenn ich richtig getestet habe, dann läßt es sich auch wunderbar mit einer Variable beschreiben.

# include <stdio.h>
# include <stdlib.h>
# include <math.h>

int main()
{
	double *F;
	int i, j, m, n;

	printf("Eingabe der Zeilenanzahl:	");
	scanf("%d", &m);
	printf("Eingabe der Spaltenanzahl:	");
	scanf("%d", &n);

	F = (double *) malloc (m*n*sizeof(double));

	for ( i = 0; i < m; ++i)
		{
		for ( j = 0; j <= n; ++j)
			{
			F[i*n+j] = i + j;
			}
		}

	printf("Aus welcher Zeile mÃ¶chten Sie einen Wert sich ausgeben lassen:	");
	scanf("%d", &i);
	printf("Welche Spalte aus dieser Zeile mÃ¶chten Sie betrachten:	");
	scanf("%d", &j);		
	printf("%lf", F[(i-1)*n+(j-1)]);
	getchar();

return 0;
}