Aufgabe:

Eine Matrix lässt sich durch ein zweidimensionales Feld double[n][n] implementieren. In
dieser Übung nehmen wir n als konstant an und defnieren daher const int n=10.
...
b) Schreiben sie eine Funktion die zwei Matrizen als Parameter erwartet, und diese miteinander
multipliziert. Eine der beiden Matrizen soll danach das Ergebnis der Multiplikation enthalten.
Liefern Sie einen Zeiger auf die Matrix zurück.

Nun der Lösungs-Quelltext (Zeilenkommentare gabs leider nicht bzw. nie ):

#include <iostream>
#include <cstdlib>
using namespace std;

const int n=10;
typedef double Matrix [n][n];
Matrix A;
Matrix B;

// hier waren noch funktionen zur ausgabe, erstellung einer nullmatrix etc.

Matrix* mult(Matrix *M, const Matrix *N)  // Matrixmultiplikation, verstehe ich nicht ganz, warum übergebe ich eigentlich zeiger?
{
 Matrix temp;  // In diese Matrix wird die Ergebnis-Matrix zwischengespeichert
  double *m,*t, *a;  // double-Zeiger
  m=(double *) M;   // verstehe ich nicht. wird die Matrix, die aus [10][10] besteht zu einem double-Zeiger gecastet? häh?
t=(double *) &temp;  // hier steht doch der Adress-Operator, weil temp kein Zeiger (wie M) ist,oder?  
for (int i = 0; i < n; ++i) {  // Scleifen für die Berechnung, verstehe ich
    for (int j = 0; j < n; ++j) {
    	double sum=0;
    	a=(double *) N;
    	a+=j;  // wird hier auf dem Feld von Zeiger-auf-Matrix N weitergesprungen?
	 for (int k = 0; k < n; ++k) {
	 	sum += (*M)[0][i*n+k]*(*N)[0][k*n+j];  // ?!?
	 	sum += (*m++)*(*a);  // *m++ : wird erst auf dem m-Feld weitergesprungen und dann der Wert an dieser Stelle des Feldes ausgelesen?
		a+=n;
	 }
	m-=n;
    	(*t++) = sum;
    }
    m+=n;
  }
 }
// hier werden wohl die berechneten Werte von der temporären Matrix in den Zeiger-auf-Matrix M kopiert

	{double *m,*t;
	 m=(double *) M;
	 t=(double *) &temp;
	 for (int i = 0; i < n; ++i) {
		for (int j = 0; j < n; ++j) {
			(*m++) = (*t++);
		}
	 }
	}
 return M;
}

Wäre suuuuper, wenn mir jemand weiterhelfen könnte.
Ich finde solch eine Aufgabe als zweite Übungsaufgabe für einen c++ Neuling irgendwie zu schwer

Wenn du Code-Tags benutzt werden sinnvollerweise keine Zeilenumbrüche eingefügt. Also überarbeite dein Posting doch einfach nocheinmal, so das man den Code auch richtig lesen kann. Wenn du cpp Code-Tags verwendest, dann wird der Code noch etwas besser dargestellt.

Gruß
Entyl Sa

Der code wurde entweder von meinem prof oder dem übungsleiter geschrieben (glaube eher der übungsleiter hat das verbrochen).

Meine Frage: Kann mir einer die mir unverständlichen Passagen des Codes erklären? Biiitteeeee

Sorry, wenn mein Posting ein wenig unverständlich war.

Wenn dies von deinem Prof oder einem Dozenten kommt hat der aber ne mehr als eigentümliche Vorstellung von lesbarem Quellcode (oder ist das vielleicht böse Absicht ?). Zeilen wie

{double *...;
...
}

sind mir zumindest recht selten begegnet. Ob das so unbedingt sein mus, ich weiss nicht. Und würde man zur Parameter-Übergabe nicht Pointer sondern Referenzen benutzen wäre das deinem Verständnis sicherlich mehr entgegengekommen. Als Beispiel für vorbildliches Coding würde ich das ganze gewiss nicht vorstellen.

mfg JJ

Beispiel:

double a() 
{
  int a = 1;
  double x = 1.0;

  for (int i = 0; i < 10; i++) {
    int b = 2;
    for (int j = i; j < 10; j++) {
      double y = 2.0;
      x = x * y;
    }
  }

  return x;
}

mfg JJ

const int n=10;
typedef double Matrix [n][n];
Matrix A;
Matrix B;

// hier waren noch funktionen zur ausgabe, erstellung einer nullmatrix etc.

Matrix* mult(Matrix *M, Matrix *N)  // Matrixmultiplikation, verstehe ich nicht ganz, warum übergebe ich eigentlich zeiger?
{
	Matrix temp;  // In diese Matrix wird die Ergebnis-Matrix zwischengespeichert	
	{
		double *m,*t, *a;  // double-Zeiger
		// verstehe ich nicht. wird die Matrix, die aus [10][10] besteht zu einem double-Zeiger gecastet? häh?  
		m=(double *) M;
		  // hier steht doch der Adress-Operator, weil temp kein Zeiger (wie M) ist,oder?  
		t=(double *) &temp;
		for (int i = 0; i < n; ++i) {  // Scleifen für die Berechnung, verstehe ich
			for (int j = 0; j < n; ++j) {
				double sum=0;
				a=(double *) N;
				a+=j;  // wird hier auf dem Feld von Zeiger-auf-Matrix N weitergesprungen?
				for (int k = 0; k < n; ++k) {
					sum += (*M)[0][i*n+k]*(*N)[0][k*n+j];  // ?!?
					// *m++ : wird erst auf dem m-Feld weitergesprungen und dann der Wert an dieser Stelle des Feldes ausgelesen?
					sum += (*m++)*(*a);  
					a+=n;
				}
				m-=n;
				(*t++) = sum;
			}
			m+=n;
		}
	}
// hier werden wohl die berechneten Werte von der temporären Matrix in den Zeiger-auf-Matrix M kopiert
	{
		double *m,*t;
		m=(double *) M;
		t=(double *) &temp;
		for (int i = 0; i < n; ++i) {
			for (int j = 0; j < n; ++j) {
				(*m++) = (*t++);
			}
		}
	}
	return M;
}

dass der code mist ist habe ich auch schon rausgefunden. alle vorgehensweisen, die in tutorials als "schlechter programmierstil" angeprangert werden, werden in diesem kurs ohne mit der wimper zu zucken praktiziert. nur ich muss da irgendwie durchblicken

... und ich habe noch 50 seiten solche quelltexte

edit: oh, entyl_sa, du warst schneller als ich. daaankeee!

1.) M = &M[0][0], d.h. m zeigt nach der Zuweisung auf das "erste" Element der Matix M, hier startet die Berechnung, logischerweise.

2.) korrekt, da temp kein Zeiger ist wird der Address-Operator verwendet.

3.) korrekt, wenn ich dich richtig verstehe. a ist ein Zeiger auf Double. Inkrementierst du den Zeiger mit n so wird der Zeiger um n "Double"-Werte weiter verschoben. Wie bei einer Berechnung in einer Schleife zu erwarten.

4.) zuerst wird der Wert "verwendet", anschliessend wird der Pointer inkrementiert (Postfix-Inkrement!)

mfg JJ

Ein paar Antworten zu dem Quellcode von Entyl_Sa

Das nimmst du besser wieder zurück
Den Code habe ich ledigtlich formatiert und gepostet.

Matrix* mult(Matrix& M, Matrix& N)
{ ...
}

So ein Cast ist eine böse Sache. Ich habe auch gehört, der soll aus den Standard gestrichen werden. Also als Anfänger gar nicht erst angewöhnen.

m=(double *) M;

Ist in deinem Fall das auch gar nicht nötig, genauso wenig wie die vielen Hilfsvariablen. Die erschweren auch nur die Lesbarkeit.

for (int i = 0; i < n; ++i) 
{ for (int j = 0; j < n; ++j) 
  { temp[i][j] = 0; // dieses Elemnet der Matrix wird jetzt berechnet.
    for (int k = 0; k < n; ++k) 
    { temp[i][j] += M[i][k] * N[k][j]; 
    }
  }
}

Und, kann man das Lesen?
Ich hab es nicht getestet, also keine Garantie für Flüschtigkeitsfehler

mfg JJ

John Doe schrieb:

1.) M = &M[0][0], d.h. m zeigt nach der Zuweisung auf das "erste" Element der Matix M, hier startet die Berechnung, logischerweise.

Ja, hätte das da so gestanden, hätte ich es auch verstanden... warum muss man das bloß so umständlich schreiben?

mfg JJ

ja, deinen quelltext kann man lesen. und sogar verstehen.

es ist nur blöd, wenn man nur solches material hat und damit arbeiten muss.

wie gesagt, ich weiss nicht, ob es mein prof oder der übungsleiter war. aber die programme die definitiv von meinem prof sind sehen genauso scheisse aus.
aber unser skript solltet ihr mal sehen... das ist die absolute krönung!

und falls ich irgendwie die prüfung bestehe, werde ich den beiden auch sagen, was ich von dem kurs halte.