Probleme mit Zeigern...

[John Doe]

1.) Einrückungen immer mit gleichen Abständen (>1)
2.) Klammerung so das Blockanfang und Blockende gleich zu erkennen sind. Zum Beispiel, öffnende Klammer in der gleichen Spalte wie die zugehörige schliessende Klammer.

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

[Entyl_Sa]

Indem du die Einrückung gescheit machst. Zum Beispiel so:

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;
}

[Ranseier]

ok, arbeite dran. wie gesagt, ich habe den code nicht geschrieben, habe ihn nur aus dem editor kopiert. ich schreibe immer übersichtlich.

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!

[John Doe]

Ein paar Antworten zu dem Quellcode von Entyl_Sa

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

[Entyl_Sa]

John Doe schrieb:

Ein paar Antworten zu dem Quellcode von Entyl_Sa

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

[gh]

Zeiger sind sehr shcön, wenn man sie wirklich braucht.
In deinem Fall erhöht eine Übergabe per Referenz die Lesbarkeit.

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

[John Doe]

So wars nicht gemeint. Sollte nur ein Hinweis sein, das ich den von dir formatierten Quellcode als "Arbeitsgrundlage" verwendet habe.

mfg JJ

[Ranseier]

Danke erstmal euch beiden!
Das hat mir sehr weitergeholfen!

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?

[John Doe]

Ich befürchte dein Prof weiss bestimmt ganz, ganz viel. Wenn aber der Code wirklich von Ihm sein sollte dann hat er wahrscheinlich in den letzten 10 Jahren keine Zeile Code in eine produktiven Umgebung geschrieben. Jeden Coder
der mir mit so was käme, würde ich ganz sicher nicht für ne kommerzielle Anwendung einsetzen. Das heisst, Bewerbung sinnlos.

mfg JJ

[Ranseier]

@gh:

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

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

[Ranseier]

@John Doe:

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.