Hallo, ich soll was ganz komisches machen.
ich finde aber leider keinen ansatz, darum bitte ich euch mir zu helfen
Aufgaben Stellung
hier der Code
C main.c:
matrix.h
matrix.c:
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
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: