[c] Matrix Struktur | Bitte dringend um hilfe

Status
Nicht offen für weitere Antworten.

xenon033

Mitglied
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:
#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:
#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:
#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
 
Zuletzt bearbeitet von einem Moderator:
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?
...?
 
Fangen wir zuerst mal beim dritten Codestück an,
alles außer erzeuge und loesche.

Du musst sowas
C++:
void liesMat(double **A, int n)
so umschreiben, dass du eine strcut übergeben kasnnt:
C++:
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:
#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:
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.
 
Zuletzt bearbeitet von einem Moderator:
Was hast du denn da jetzt :suspekt:
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.
 
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.
 
Status
Nicht offen für weitere Antworten.
Zurück