Hallo, ich soll was ganz komisches machen.

ich finde aber leider keinen ansatz, darum bitte ich euch mir zu helfen

Aufgaben Stellung

Bitte schreibe die Matrix-Aufgabe so um, dass nun anstelle von "double** A" und "int n" eine Matrix-Struktur uebergeben wird, die die Komponenten einer Matrix sowie ihre Dimension (n Zeilen, m Spalten) enthaelt.

struct matrix {
int m;
int n;
double **komp;
};

a) Arbeite zunaechst mit statisch erzeugten Strukturen
b) und danach mit dynamisch erzeugten Strukturen, d.h.
uebergebe dann nur noch einen Zeiger auf die jeweilige Struktur
an die aufgerufene Funktion.

hier der Code

C main.c:

Code :

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57

#include <stdio.h> #include <stdlib.h> #include "matrix.h" #include "matrix.c"   /******************************************************************************* * Main * A - E sind die Matrizen * Das Programm Addiert, Multipliziert und Additiv Inverntiert zwei Matrizen * miteinander und gibt die Ergebnisse aus. *******************************************************************************/ int main(void) { struct matrix { int m; int n; double **komp; };       A = erzeugeMat(3); B = erzeugeMat(3); C = erzeugeMat(3); D = erzeugeMat(3); E = erzeugeMat(3);   liesMat(A,3); liesMat(B,3);   zeigeMat(A,3); zeigeMat(B,3);   printf("\nAddition: \n"); addiereMat(C,A,B,3); zeigeMat(C,3);   printf("\nMultiplikation: \n"); multipliziereMat(D,A,B,3); zeigeMat(D,3);   printf("\nAdditiv Invert: \n"); invertAddMat(E,A,3); zeigeMat(E,3);   /*--------------------------------------------------------------------------- | Allokierten speicher wieder frei geben ---------------------------------------------------------------------------*/ loescheMat(3, A); loescheMat(3, B); loescheMat(3, C); loescheMat(3, D); loescheMat(3, E);   system("pause"); return 0; }

matrix.h

Code :

1 2 3 4 5 6 7 8 9 10 11 12

#ifndef MATRIX_H #define MATRIX_H   double** erzeugeMat(int n); void loescheMat(int n, double **A); void liesMat(double **A, int n); void zeigeMat(double **A, int n); double **addiereMat(double **A, double **B, double **C, int n); double **multipliziereMat(double **A, double **B, double **D, int n); double **invertAddMat(double **A, double **E, int n);   #endif

matrix.c:

Code :

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163

#ifndef MATRIX_C #define MATRIX_C   /******************************************************************************* * Erzeugt Matrix. *******************************************************************************/ 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); }   /******************************************************************************* * reservierten Speicher wieder frei geben. *******************************************************************************/ void loescheMat(int n, double **A) {   /*--------------------------------------------------------------------------- | Gibt speicher wieder frei. ---------------------------------------------------------------------------*/ for(i=0; i<n; ++i) { free(A[i]); } free(A); }   /******************************************************************************* * Eingabe der Werte für die Matrix. *******************************************************************************/ void liesMat(double **A, int n) { k = 0;   /*--------------------------------------------------------------------------- | Datei wird geoeffnet. ---------------------------------------------------------------------------*/ datei = fopen("matrix.txt", "r+t"); if(datei != NULL) {   /*------------------------------------------------------------------------ | Eingabe der Matrix Werte von A und B. ------------------------------------------------------------------------*/ for(i=0; i<n; ++i) { for(j=0; j<n; ++j) {   /*------------------------------------------------------------------ | Werte werden aus der Datei matrix.txt gelesen und dem | Array ueber geben. ------------------------------------------------------------------*/ fscanf(datei,"%d",&k); A[i][j] = k; } } } fclose(datei); }   /******************************************************************************* * Eingabe Werte der erzeugten Matrix anzeigen. *******************************************************************************/ void zeigeMat(double **A, int n) {   /*-------------------------------------------------------------------------- | Ausgabe der Eingabe Werte. --------------------------------------------------------------------------*/ for(i=0; i<n; ++i) { printf("\n"); for(j=0; j<n; ++j) { printf("%7.4lf ",A[i][j]); } }   printf("\n"); }   /******************************************************************************* * Addition. *******************************************************************************/ int addiereMat(double **C, double **A, double **B, int n) {   /*--------------------------------------------------------------------------- | Addition beider Matrizen. ---------------------------------------------------------------------------*/ for(i=0; i<n; ++i) { for(j=0; j<n; ++j) { C[i][j] = A[i][j] + B[i][j]; } } return 0; }   /******************************************************************************* * Multiplikation *******************************************************************************/ double **multipliziereMat(double **D, double **A, double **B, int n) {   /*--------------------------------------------------------------------------- | Multipliziert beide Matrixe. ---------------------------------------------------------------------------*/ for(k=0;k<n;++k) { for(i=0;i<n;++i) { D[k][i] = 0.0;   for(j=0;j<n;++j) { D[k][i] += A[k][j]*B[j][i]; } } } return 0; }   /******************************************************************************* * Additiv invertieren. *******************************************************************************/ double **invertAddMat(double **E, double **A, int n) { for(i=0; i<n; ++i) { for(j=0; j<n; ++j) { m = A[i][j]; E[i][j] = m - (A[i][j] * 2); } } return 0; }   #endif

Kann einer Helfen?

Bitte, Danke.

Irgendein Lösungs ansatz oder nach was ich googlen soll oder die Aufgaben stellung anders Fomulieren. am ende ist die gar nicht so schwer wie ich denke

Hi

zuerst wäre einmal interessant, was das Problem ist.

Funktioniert es und du willst Vorschläge, was man besser machen kann?
Funktioniert es nicht und du bekommst Fehlermeldungen? Welche? In welcher Zeile?
...?

ich versthe nicht wie ich die aufgabe umsetzen soll.
grad die aufgabe b.

das ist mein problem.

Fangen wir zuerst mal beim dritten Codestück an,
alles außer erzeuge und loesche.

Du musst sowas

Code cpp:

1	void liesMat(double **A, int n)

so umschreiben, dass du eine strcut übergeben kasnnt:

Code cpp:

1	void liesMat(struct matrix *A)

Die Länge/Breite (was vorher beides n war) findest du in der struct, mit
A->m
a->n
Der Inhalt ist
a->komp


Generell sollst aber glaub ich ein "int**" statt "double**" nehmen (wie im main zu sehen).
Und waumnennst du komp nicht inhalt oder so?

komp ist gefordert. k.a. warum
ich habe mir die ganze zeit ein programm geschrieben um die sache zu verstehen. leider gibt es einen pointer fehler

Code :

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51

#include <stdio.h> #include <stdlib.h>   struct matrix { int m; int n; double **matrixx;   };   void zeigeMat(double **matrixx);   int main (void) { int i; double k; k = 0.0; struct matrix *liste;   liste->matrixx = (double **)malloc((3)*sizeof(liste));   for( i=0; i<3; ++i) { liste->matrixx[i] = (double **)malloc((3)*sizeof(liste));   if( liste->matrixx[i] == NULL) { printf("ERROR(%s, %d)", __FILE__,__LINE__); system("pause"); } } zeigeMat( liste->matrixx);   system("pause"); return 0; }   void zeigeMat(double **matrixx) { int k=0; int i,j; for(i=0; i<3; ++i) { printf("\n"); for(j=0;j<3; ++j) { printf("%1.2lf\t ", matrixx[i][j]); ++k; } } }

Zeile 24 ([Warning] assignment from incompatible pointer type )

Code :

1	liste->matrixx[i] = (double **)malloc((3)*sizeof(liste));

warum und ist dieser ansatz richtig für die lösung in dem anderen programm?
muss ja am ende nur übernehmen sowie anpassen.

Was hast du denn da jetzt
Warum machst du das nicht einfach der Reihe nach, statt alles zu überstürzen?

Und nein, das was du da hast, passt mit deiner Aufgabenstellung nicht zusammen.
Nichtmal komp ist da.

ey ich hab echt kein plan. was stimmt den nicht?

Dein Fehler in Zeile 24 ist, dass du auf (double**) castest, du darfst hier aber nur mit einem Pointer arbeiten (z.B.: double*).
matrixx is zwar ein Pointer auf Pointer, da du aber mit einem Element von matrix arbeitest (matrix[i]), darfst du nur mehr eine Dimension verwenden (also mit einem Stern).

Lg

geht trotzdem nicht.

wie wollen wir das machen, bleiben wir bei meinem kleinen code der als test dient oder können wir das gleich am großen durchsprechen?

der neue fehler auf zele 19
liste->matrixx = (double **)malloc((3)*sizeof(liste));
auch wenn ich ein sternchen weg mache ist dieser fehler vorhanden

Bleiben wir - zum dritten Mal - beim großen.

Erste Anweisungen hast du erhalten, bevor das nicht angepasst ist
machts überhaupt keinen Sinn, am restlichen Programm herumzuändern.

Und beachte die Netiquette, P. 15.

ich verstehe nicht wie ich das anpassen soll. in deinem beispiel fehlt zum beispiel das n in

Code :

1	void liesMat(struct matrix *A)

.

Wo defeniere ich das n(die größe | z.b. n= 3)?
Der wird doch nicht einfach erkennen das er es automatisch irgendwie regeln soll.

Auch wenn es dreist klingt aber kannst du den Code nicht fertig machen und den Code KOmmentieren?
Auch anhaltspunkte was ich zu dem thema durchlesen kann wäre super. Da ich solche sachen in Zukunft öfter brauchen werde. Es würde mir ja nichts bringen wenn ich das fertige ding ohne irgendwelche anhaltspunkte bekommen würde.

Falls nein würde ich dir gern meine icq nummer geben damit ich nicht hier die ganze zeit schreiben muss (wegen Regel -> das Forum ist kein Chat)

Wenn du mit matrixx[i] arbeitest, darfst du bei malloc nur 1 * verwenden!
Wenn du mit matrixx arbeitest, musst du bei malloc 2 * verwenden!

Hi.

Da hat jemand bei Strukturen nicht aufgepasst...

Das ist eine Struktur:

Code c:

1 2 3 4 5

struct matrix {   int m;   int n;  double **komp; };

Sie enthält die Elemente m, n und komp. D.h. es werden die Variablen die du vorher einzeln hattest zu einer Einheit zusammengefaßt.

Legen wir mal eine Struktur an:

Code c:

1 2 3 4 5

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

Diese Matrix kannst du dann auch an eine Funktion übergeben usw.

Etwas klarer geworden?

Gruß

Woher das n kommt, steht doch oben (und jetzt sogar in zwei Posts)

Wenn ich dir das fertig mach, kannst du es danach erst recht nicht.
Anhaltspunke...das Galilieo Openbook zu C.
Link ist einer hier: http://www.tutorials.de/c-c/380577-h...er.html#lernen

Icq: Auch nein. Die Chat-Regel meint, dass nicht alles aus Drei-Wörter-Posts bestehen soll.
Hab außerdem kein Icq.

Den Regelpunkt, auf den ich dich hingewiesen hab, hältst du aber noch immer nicht ein.

Ich danke für eure bisherige Hilfe aber sie bringt mir nichts.

c:

Code :

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55

#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;   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) { printf("%1.2lf\t ", komp[i][j]); ++k; } } }

Beim Debuggen ist es immer noch das erste malloc falsch. Warum?