✔ [c] Matrix Struktur | Bitte dringend um hilfe

Status
Nicht offen für weitere Antworten.
Ich lese bis jetzt nur das mit dem 1 * und 2 *.

Aber genau so habe ich es doch gemacht.


Ich muss etwas sehen bevor ich es verstehe. Ich habe bis jetzt nur das gefühl das ihr mir irgendwelche Brocken hinwerft, die ich selbst mir irgendwie da rein basteln soll. Aber ich bekomme es nicht hin.

Statisch habe ich schon hinbekommen. Das ist war wieder einfach aber dynamisch halt nicht.
 
Zuletzt bearbeitet:
Schau mal:

Bei dir steht eine Zeile so in der Art:
Code: 
liste->komp = (double**)malloc((liste->n)*sizeof(double));

Das ist falsch, da komp ein Pointer auf einen Pointer ist. Du reservierst aber double Werte. Das ist falsch, du musst double* Werte reservieren!

Also so:

Code: 
liste->komp = (double**)malloc((liste->n)*sizeof(double*));
Der Stern beim letzten double!

Lg
 
Nochmal langsam:

liste ist ein Zeiger. Um irgendwas mit dem Zeiger machen zu können muß der erstmal initialisiert werden (er muss auf ein gültiges struct matrix zeigen).
C: 
liste = malloc(sizeof(struct matrix));
(Der Name "liste" suggeriert hier es könnte sich um eine Liste Datenstruktur handeln... ist etwas ungünstig)

\edit: Danach machst du das was ibafluss geschreiben hat.

Du solltest dir besser eine Funktion z.B. "newMatrix" schreiben die dir eine neue Matrix erzeugt und zurückgibt.
C: 
struct matrix* newMatrix(int x, int y) {
  ... malloc(...)

  return m;
}
Gruß
 
Zuletzt bearbeitet:
Endlich, ich habe es verstanden. Das war aber auch eine Geburt mit mir.

Ich habe das vergessen im Quelltext.

deepthroat hat gesagt.:
Nochmal langsam:
C: 
liste = malloc(sizeof(struct matrix));
Zum Vergrößern anklicken....

und natürlich auch die anderen wichtigen Sachen.

Jetzt Funktioniert alles.
Vielen lieben Dank.

P.S.:

Beispiel C:
Code: 
#include <stdio.h>
#include <stdlib.h>

struct matrix {
int m;
int n;
double **komp;
}*liste, dieMatrix;

void zeigeMat(double **matrixx);

int main (void)
{
int i;
double k;
k = 0.0;

liste = malloc(sizeof(struct matrix));

dieMatrix.m = 5;
dieMatrix.n = 5;

/*---------------------------------------------------------------------------
| Erstellung der Matrix.
---------------------------------------------------------------------------*/
liste->komp = (double**)malloc((liste->n)*sizeof(double*));

for( i=0; i<3; ++i)
{
liste->komp[i] = (double *)malloc((liste->n)*sizeof(double));

if( liste->komp[i] == NULL)
{
printf("ERROR(%s, %d)", __FILE__,__LINE__);
system("pause");
}
}
zeigeMat(liste->komp);

system("pause");
return 0;
}

void zeigeMat(double **komp)
{
int k=0;
int i,j;
for(i=0; i<3; ++i)
{
printf("\n");
for(j=0;j<3; ++j)
{
komp[i][j] = k;
printf("%1.2lf\t ", komp[i][j]);
++k;
}
}
}

Jetzt versuch ich es mal in mein Hauptprogramm zu schieben. Hoffentlich Ohne irgendwelche Probleme.

Wie kann ich jetzt die Struktur die in der main.c ist in der matrix.c aufrufen?

Code: 
double** erzeugeMat(struct matrix n)
Aufrufen will ich sie so:
Code: 
A = erzeugeMat(dieMatrix.n);

geht nicht. Ein Pointer Problem oder?
 
Zuletzt bearbeitet von einem Moderator:
Code: 
double** erzeugeMat(int n)
{
 
   /*---------------------------------------------------------------------------
   | Erzeugung der Matrix.
   ---------------------------------------------------------------------------*/
   A = (double **)malloc((n)*sizeof(double));
 
   if( NULL == A)
   {
      printf("Fehler bei malloc...");
   }
 
   for( i=0; i<n; ++i)
   {
      A[i] = (double *)malloc((n)*sizeof(double));
 
      if(A[i] == NULL)
      {
         printf("ERROR(%s, %d)", __FILE__,__LINE__);
         system("pause");
      }
   }
   return(A);
}

In der Funktion wird mit A gearbeitet, aber was ist A? Ist das irgendwo definiert?
 
In dem Funktionskopf selbst.

oder Wir bleiben bei dem Beispiel Code indem ich einfach versuche in einer anderen .c Datei den Code Aufzurufen.

Bis jetzt sieht das so bei mir aus:

main.c:
Code: 
#include <stdio.h>
#include <stdlib.h>
#include "cc.c"

struct matrix {
int m;
int n;
double **komp;
}*liste, dieMatrix;

void zeigeMat(double **matrixx);

int main (void)
{
dieMatrix.m = 5;
dieMatrix.n = 5;

erzeugeMat(liste->n,liste->m,struct matrix);
zeigeMat(liste->komp);

system("pause");
return 0;
}

cc.c:

Code: 
#include <stdio.h>
#include <stdlib.h>

void zeigeMat(double **komp)
{
int k=0;
int i,j;
for(i=0; i<3; ++i)
{
printf("\n");
for(j=0;j<3; ++j)
{
komp[i][j] = k;
printf("%1.2lf\t ", komp[i][j]);
++k;
}
}
}


double **erzeugeMat(int n, int m, struct matrix)
{
int i;
double k;
k = 0.0;

liste = malloc(sizeof(struct matrix));


/*---------------------------------------------------------------------------
| Erstellung der Matrix.
---------------------------------------------------------------------------*/
liste->komp = (double**)malloc((liste->n)*sizeof(double*));

for( i=0; i<3; ++i)
{
liste->komp[i] = (double *)malloc((liste->n)*sizeof(double));

if( liste->komp[i] == NULL)
{
printf("ERROR(%s, %d)", __FILE__,__LINE__);
system("pause");
}
}
return(komp);
}

Geht natürlich nicht. Ich tippe darauf das der Funktionskopf schon falsch ist
Code: 
double **erzeugeMat(int n, int m, struct matrix)

Sowie der Rückgabewert.
Wie macht man es richtig?
 
Zuletzt bearbeitet von einem Moderator:
Du hast da immer noch etwas missverstanden.

Du brauchst die "dieMatrix" Variable doch nicht. Es sei denn du willst sie als Matrix verwenden...

Es sollte so aussehen:
C: 
struct matrix *A = erzeugeMatrix(5, 3);
struct matrix *B = erzeugeMatrix(3, 5);
...
struct matrix *C = addiereMatrix(A, B);

Schreib doch erstmal deine zeigeMat Funktion um, so dass sie eine Matrix (also ein struct matrix*) als Parameter akzeptiert.

\edit: den Funktionskopf habe ich dir doch schon hingeschrieben...
 
main.c
Code: 
#include <stdio.h>
#include <stdlib.h>
#include "cc.c"

struct matrix
{
int m;
int n;
double **komp;
}*liste, dieMatrix;

void zeigeMat(double **matrixx);
double **erzeugeMat(int **n, int **m)
int main (void)
{
struct matrix *A = erzeugeMatrix(5, 3);

zeigeMat(liste->komp);

system("pause");
return 0;
}

cc.c
Code: 
#include <stdio.h>
#include <stdlib.h>

struct matrix
{
int m;
int n;
double **komp;
}*liste, dieMatrix;

void zeigeMat(double **komp)
{
int k=0;
int i,j;
for(i=0; i<3; ++i)
{
printf("\n");
for(j=0;j<3; ++j)
{
komp[i][j] = k;
printf("%1.2lf\t ", komp[i][j]);
++k;
}
}
}


double **erzeugeMat(int dieMatrix->n, int dieMatrix->m)
{
int i;
double k;
k = 0.0;

liste = malloc(sizeof(struct matrix));
dieMatrix.m = 5;
dieMatrix.n = 5;

/*---------------------------------------------------------------------------
| Erstellung der Matrix.
---------------------------------------------------------------------------*/
liste->komp = (double**)malloc((liste->n)*sizeof(double*));

for( i=0; i<3; ++i)
{
liste->komp[i] = (double *)malloc((liste->n)*sizeof(double));

if( liste->komp[i] == NULL)
{
printf("ERROR(%s, %d)", __FILE__,__LINE__);
system("pause");
}
}
return(liste->komp);
}

Wo muss die Struktur stehen?
Ich Übergebe vin der Main.c in die cc.c, wie muss der Funktionskopf sein?
Habt ihr Links zu diesem Thema?
 
Zuletzt bearbeitet von einem Moderator:
sinnlos. ich bekomm es nicht hin. thread kann gelöscht werden.

Vom Ersten post sieht die headerdatei so aus
Code: 
double** erzeugeMat(int n);
void loescheMat(int n, double **A);
void liesMat(double **A, int n);
void zeigeMat(double **A, int n);
int addiereMat(double **C, double **A, double **B, int n);
double **multipliziereMat(double **D, double **A, double **B, int n);
double **invertAddMat(double **E, double **A, int n);

int i, j, k;

double m;
double **A = NULL;
double **B = NULL;
double **C = NULL;
double **D = NULL;
double **E = NULL;

FILE *datei = NULL;

ich muss die lösung sehen um es zu verstehen und nicht schritt für schritt erklärt bekommen oder immer noch das gleich zu schreiben obwohl ich es nicht verstanden habe. mit anderen worten erklären wäre besser.
 
Zuletzt bearbeitet von einem Moderator:
Status
Nicht offen für weitere Antworten.

Neue Beiträge

Zurück