Aufgabe:
*Ermitteln Sie den maximalen Abstand zweier Punkte des Feldes, das Sie mit
neuesPunktFeld() erzeugt haben. Prototyp der Prozedur:
double maxAbstand(Punkt **, Punkt *, Punkt );
Der erste Parameter ist für die Übergabe des Feldes, mit dem zweiten und dritten
Parameter sollen die ermittelten Punkte zurückgegeben werden.

Folgendes habe ich ausgearbeitet:

...
cout << "\n*dynamische Punkt Feld Erzeugung*\n";
	Punkt **arrPunkt = neuesPunktFeld(ARRAY_GROESSE);
	for(int i=0; i<ARRAY_GROESSE; i++)
	{
		printPunkt( *(arrPunkt[i]) );
	}

	cout << "\n*Ermittelter maximaler Abstand zwischen 2 Punkten aus dem Feld*\n";
	Punkt *tmp1, *tmp2;
	cout << tmp1 << "\t" << tmp2 << endl;
	cout << "Maximaler Abstand ist bei:" << endl;
	cout << maxAbstand(arrPunkt, tmp1, tmp2) << endl;
	cout << tmp1 << "\t" << tmp2 << endl;
	printPunkt(*tmp1);
	printPunkt(*tmp2);
	return 0;
}

double maxAbstand(Punkt **arrPunkt, Punkt *p1, Punkt *p2)
{
	double nMax = 0;
	double nTempCalc; 
	//arrPunkt ist übergebenes Feld
	//über p1 und p2 werden die Punkte zurückgegeben welche den größten abstand haben
	//double abstand(Punkt p1, Punkt p2) 
	for(int x=0; x<ARRAY_GROESSE; x++)
	{
		nTempCalc = abstand( *(arrPunkt[x]), *(arrPunkt[ARRAY_GROESSE-1-x]) );

		if( nMax < nTempCalc) {
			p1 = arrPunkt[x];
			p2 = arrPunkt[ARRAY_GROESSE-x-1];
			nMax = nTempCalc;
		}
	}

	return nMax;
}

Problem:
Der Inhalt der Punkt Pointer "tmp1" und "tmp2" ist nur Müll auch die Referenzierte Adresse ändert sich nicht von den beiden Variablen.

Frage
Muss ich für die Punkt Pointer Variablen tmp1 und tmp2 ein Extra speicher mit new anlegen? Eigentlich will ich die ja nur auf einen bereits vorhandenen Speicher referenzieren

Wie dem auch sei, tmp1 und tmp2 sind bei dir zwei uninitialisierte Zeiger, mit denen du einfach arbeitest, als würden die schon irgendwohin zeigen, wo es POINT-Objekte gibt.

Wie der code unter den Voraussetzungen auszusehen hat, kann ich Dir nicht sagen, weil ich die Aufgabenstellung nicht wirklich verstanden habe. Ich finde sie unpräzise. Vielleicht fehlt mir da auch etwas Kontext.

typedef struct {
	double x;
	double y;
} Punkt;

double abstand(Punkt p1, Punkt p2) 
{
	return sqrt( (p2.y-p1.y)*(p2.y-p1.y) + (p2.x-p1.x)*(p2.x-p1.x) );
}

Tja, finde sie auch nicht ganz Toll aber das Semester hat erst begonnen und das ist nun die erste Aufgabe...

BTW in C++ schreibt man

struct Punkt {
    double x;
    double y;
};

Die Version mit typedef ist in C notwendig, wenn man den so definierten Datentyp Punkt nennen will statt immer ausführlich struct Punkt schreiben zu müssen, in C++ heißt der Typ von vornherein nur Punkt .

Punkt tmp1, tmp2;
cout << tmp1 << "\t" << tmp2 << endl;
cout << "Maximaler Abstand ist bei:" << endl;
cout << maxAbstand(arrPunkt, &tmp1, &tmp2) << endl;

Besser wären jedoch Referenzen als Parameter (aber die Aufgabenstellung ist ja leider anders).

Die Version mit typedef ist in C notwendig, wenn man den so definierten Datentyp Punkt nennen will statt immer ausführlich struct Punkt schreiben zu müssen, in C++ heißt der Typ von vornherein nur Punkt .

Apropos C und C++: Da das einzige an dem Code, was kein typisches^* C ist, das cout ist, würde ich doch gerne vom Threadersteller erfahren, ob die couts vielleicht von ihm auf eigene Faust eingebaut wurden. Wenn das nämlich ein C-Kurs ist und die couts vom TE stammen, dann würde das so einiges erklären. Und man könnte auch produktiver helfen, als nur zu sagen, dass das ganz besch...eidenes C++ ist.

^*: Damit meine ich nicht "gut". Bloß typisch für C-Anfängerkurse.

Kannst du mal die Funktion neuesPunktFeld zeigen?

BTW in C++ schreibt man

struct Punkt {
    double x;
    double y;
};

Die Version mit typedef ist in C notwendig, wenn man den so definierten Datentyp Punkt nennen will statt immer ausführlich struct Punkt schreiben zu müssen, in C++ heißt der Typ von vornherein nur Punkt .

@Bashar
Danke für den Tip mit der "typedef" wusste ich nicht

Punkt **neuesPunktFeld(int nDim)
{
	Punkt **arrPunkt = new Punkt*[nDim];
	for(int i=0; i<nDim; i++) {
		arrPunkt[i] = neuerPunkt();
	}
	return arrPunkt;
}

@Th6
Leider, gibt es da wohl kein Spielraum für den Funktionsaufbau...aber trotzdem Danke

Bashar schrieb:

Die Version mit typedef ist in C notwendig, wenn man den so definierten Datentyp Punkt nennen will statt immer ausführlich struct Punkt schreiben zu müssen, in C++ heißt der Typ von vornherein nur Punkt .

Apropos C und C++: Da das einzige an dem Code, was kein typisches^* C ist, das cout ist, würde ich doch gerne vom Threadersteller erfahren, ob die couts vielleicht von ihm auf eigene Faust eingebaut wurden. Wenn das nämlich ein C-Kurs ist und die couts vom TE stammen, dann würde das so einiges erklären. Und man könnte auch produktiver helfen, als nur zu sagen, dass das ganz besch...eidenes C++ ist.

^*: Damit meine ich nicht "gut". Bloß typisch für C-Anfängerkurse.

Ne das ist ein C++ kurs, C hatten wir bereits und du hast recht ausser cout und <iostream> ist hier C++ sehr gering

Mit einer einfachen Schleife wirst du kaum alle Punkte miteinander vergleichen können.
Denn du musst ja den
1. mit dem 2. Punkt vergleichen
1. mit dem 3.
1. mit dem 4.
....
1. mit dem ARRAY_GROESSE.
2. mit dem 3.
2. mit dem 4.
...
2. mit dem ARRAY_GROESSE.
...
ARRAY_GROESSE-1 mit dem ARRAY_GROESSE. Punkt vergleichen

Ja ist mir bewusst, habe die Funktion aber aufgrund des Problems nicht mehr weiter ausgebaut...Werde noch ein innere Schleife einbauen die von oben nach unten -1 zählt.

...
    Punkt *tmp1 = new Punkt;
	Punkt *tmp2 = new Punkt;

	cout << "Maximaler Abstand ist bei:" << endl;
	cout << maxAbstand(arrPunkt, tmp1, tmp2) << endl;
	printPunkt(*tmp1);
	printPunkt(*tmp2);
	return 0;
}

double maxAbstand(Punkt **arrPunkt, Punkt *p1, Punkt *p2)
{
	double nMax = 0;
	double nTempCalc; 

	for(int x=0; x<ARRAY_GROESSE; x++)
	{
		for(int y=ARRAY_GROESSE-1; y>0; y--)
		{
			nTempCalc = abstand( *(arrPunkt[x]), *(arrPunkt[y]) );

			if( nMax < nTempCalc) {
				*p1 = *arrPunkt[x];
				*p2 = *arrPunkt[ARRAY_GROESSE-x-1];
				nMax = nTempCalc;
			}
		}
	}

	return nMax;
}

Punkt tmp1, tmp2;

    cout << "Maximaler Abstand ist bei:" << endl;
    cout << maxAbstand(arrPunkt, &tmp1, &tmp2) << endl;

Ist zwar immer noch grauenhaft, aber wenigstens ohne direktes Speicherloch.

Ich habe das nun so gelöst, obwohl ich mit dieser Lösung nicht zufrieden bin, da ich einen neuen Speicher reserviere...

Wieso also reservierst du selbst Speicher? Die richtige Lösung wäre, eine automatische Stack-Variabe zu nehmen:

Punkt tmp1;
    Punkt tmp2;

Edit: Sei verdammt, SeppJ!

Ich habe das nun so gelöst, obwohl ich mit dieser Lösung nicht zufrieden bin, da ich einen neuen Speicher reserviere...

Wieso also reservierst du selbst Speicher? Die richtige Lösung wäre, eine automatische Stack-Variabe zu nehmen:

Punkt tmp1;
    Punkt tmp2;

Edit: Sei verdammt, SeppJ!

Stimmt auch wieder, bin irgendwie bei den ganzne Pointer und Adresse Variablen hängengeblieben...Danke

Ist zufälligerweise der Begriff Jürgen Wolf in deinem Bekanntenkreis gefallen?

Übrigens: Sagt dir der Begriff Speicherloch was?

PS:
Ich bin überhaupt kein Freund von Zeigern auf Zeigern...

ka wer das sein soll...sollte man Jürgen Wolf kennen? und was ist an meinem Programmierstill nicht in Ordnung?

Memoryleaks sagt mir was, aber da das eine "Übung" habe ich mir keine gedanken gemacht über delete von Variablen...

@Bitte ein Bit

ka wer das sein soll...sollte man Jürgen Wolf kennen? und was ist an meinem Programmierstill nicht in Ordnung?

Nein, Jürgen Wolf sollte man nicht kennen. Der ist Autor von den schlechtesten C/C++* Lehrbüchern überhaupt.
Und was deinen Programmierstil angeht:
In C++ nutzt man beispielsweise Referenzen für pass-by-reference, nicht Pointer.
Und Arrays übergibt man nach dem Iteratorenprinzip, ein Zeiger auf das erste Element und eins hinter das letzte Element, dann kann man folgende Schleifen schreiben:

for (; begin != end; ++begin)
    // tu was mit *begin

Dann muss man auch nicht viel ändern, um den Code für STL-Container (die man eh bevorzugen sollte) anzupassen.

*Man, meine versteckten Witze werden immer besser.

Und Arrays übergibt man nach dem Iteratorenprinzip, ein Zeiger auf das erste Element und eins hinter das letzte Element

Um den Vorteil hier noch ein wenig deutlicher zu machen: Man muss nicht das komplette Array angeben, auch Untermengen sind möglich.

Die Funktion (oder besser das Funktionstemplate) ist so nicht an den Containertyp oder den Iterator gebunden, und kann praktisch über alle Mengen iterieren. Extrem Flexibel.

das erste Element und eins hinter das letzte Element

Beiläufig werfe ich für den TE noch den Begriff rechtsoffenes Intervall ein.

Trotzdem Danke an alle

Nein, Jürgen Wolf sollte man nicht kennen. Der ist Autor von den schlechtesten C/C++* Lehrbüchern überhaupt.

Genau deswegen frage ich ja nach. Sein Code hat eine gewisse Ähnlichkeit zu JW. Und man möchte ja vermeiden dass er einen solchen Stil anschlägt.

@DKlay13:

Hmm ok das kannte ich zwar aber selten bis nie verwendet, aber wieso wird mein Programmierstill runtergemacht?

Tut mir Leid, ich möchte dich oder deinen Programmierstil nicht runtermachen sondern nur dir einige Fehler in deinem Code aufzeigen.

Wenn dein Prof. deinen neuen Code nicht akzeptiert, dann mach es halt so wie er es mag.

1.) Speicherloch: Wer ein new aufruft, muss auch das entsprechende delete aufrufen. Besser ist da RAII oder Smart Pointer (unique_ptr,...). Es gibt kein Argument zu sagen: soll sich das Betriebsystem um die Freigabe kümmern!
2.) Zeiger sind gemein. Sie können auf die gewünschten Daten zeigen, aber auch auf nullptr, 0xCCCCCCCC oder ähnlichem. Referenzen gefallen mir da besser.
3.) const ist dein Freund. Schränkt deinen Code in einer schönen Art und Weise ein, und vermeidet unerwünschte Seiteneffekte wie:

double maxAbstand(Punkt **arrPunkt, Punkt *p1, Punkt *p2)
{
    double nMax = 0;
    double nTempCalc;
    //arrPunkt ist übergebenes Feld
    //über p1 und p2 werden die Punkte zurückgegeben welche den größten abstand haben
    //double abstand(Punkt p1, Punkt p2)
    for(int x=0; x<ARRAY_GROESSE; x++)
    {
        nTempCalc = abstand( *(arrPunkt[x]), *(arrPunkt[ARRAY_GROESSE-1-x]) );

        if( nMax < nTempCalc) {
            p1 = arrPunkt[x];
            p2 = arrPunkt[ARRAY_GROESSE-x-1];
            nMax = nTempCalc;
        }
    }
    // So hier bin ich gemein. Ich lösche das Punkt Array.
    DeletePointArray(arrPunkt);
    // Frage: Wohin zeigen nun p1 und p2? Und wie bemerke ich den Fehler?
    // Ist eigentlich sehr gemeiner Fall. Denn sobald jemand das Array verändert,
    // werdem deine Zeiger oder deren Inhalt p1 und p2 ungültig. (Punkt einfügen)
    // Ich glaube hier wäre es besser die Punkt Call By Value zurückzugeben!
    return nMax;
}

4.)

//double abstand(Punkt p1, Punkt p2)
double abstand(const Punkt& p1, const Punkt& p2)  // Kein Overhead, da Call By Reference, nicht Call by Value.
// Call by Value wäre hier vermutlich auch noch ok, da Point realtiv klein ist
{
    return sqrt( (p2.y-p1.y)*(p2.y-p1.y) + (p2.x-p1.x)*(p2.x-p1.x) );
}

4.) Nicht ganz so wichtig: Ich bin kein Freund von Zeiger auf Zeigern. Ich habe ständig das Problem wie ich darauf zugreife:

Punkt **arrPunkt = neuesPunktFeld(ARRAY_GROESSE);
(*arrPunkt)[0] = Punkt;
//oder 
*(arrPunkt[0]) = Punkt;

5.) Nicht ganz so wichtig: Um ein Array hochzählen sollte man zumindestens ein unsigned int nutzen oder besser size_t und ähnliches. Problem: Wenn die int nur 16 Bits hat, kannst du so nur 2^15 Elemente = 32768 ansprechen.

Punkt **neuesPunktFeld(int nDim)
{
    Punkt **arrPunkt = new Punkt*[nDim];
    //for(int i = 0; i < nDim; i++) // so finde ich es lesbarer
    for(unsigned int i = 0; i < nDim; i++) // so finde ich es lesbarer
    {
        arrPunkt[i] = neuerPunkt();
    }
    return arrPunkt;
}

Punkt *neuerPunkt()
{
    ...
}

Punkt **neuesPunktFeld(int nDim)
{
	Punkt **arrPunkt = new Punkt*[nDim];
	for(int i=0; i<nDim; i++) {
		arrPunkt[i] = neuerPunkt();
	}
	return arrPunkt;
}

Die Funktion "neuesPunktFeld" erzeugt kein Feld aus Punkten sondern ein Feld aus Zeigern auf Punkten. Es ist also nicht nur gelogen sondern auch ungeschickt.

In gutem, modernem C++ würde das eher so aussehen:

Punkt neuerPunkt() // <-- kein Zeiger als Rückgabewert
{
    ...            // <-- kein new
}

vector<Punkt> neuesPunktFeld(int nDim) // <-- kein Zeiger als Rückgabewert
{
    vector<Punkt> v;                   //     hier reserviert der vector für
    v.reserve(nDim);                   // <-- uns den Speicher und kümmert
    for (int i=0; i<nDim; ++i) {       //     sich dann selbst um die Freigabe
        v.push_back(neuerPunkt());
    }
    // Das reserve ist optional. push_back kann von sich aus auch den
    // vector vergrößern. Aber hier wissen wir schon die finale Größe
    // und können es dem vector per reserve mitteilen. Das wird dann
    // ein kleines bisschen effizienter so.
    return v;
}

Man kann das auch noch etwas generischer machen, so dass die Funktion neuesPunktFeld eine nahezu beliebige schon existierende Datenstruktur befüllen kann. Aber das wäre hier wahrscheinlich Overkill.

Fazit: Nimm das, was man Dir da beibringen will, nicht für bare Münze. Möglicherweise kennt Dein Lehrer auch nicht die Größe seiner Wissenslücken; denn sonst könnte er Euch nicht guten Gewissens so einen schlechten Stil beibringen. typedef struct und Doppel-Zeiger ohne eine Spur von RAII sind leider Warnhinweise bzgl. Inkompetenz. Ich empfehle Dir ein begleitendes Selbststudium basierend auf 'nem schlauen Buch, was einen guten Ruf genießt. Achtung: guter Ruf != positive Amazon-Bewertungen. Ein Anfänger, der keine Ahnung hat, kann ein Buch höchstens hinsichtlich Schreibstil bewerten jedoch nicht die Qualität des technischen Inhalts.

Aber das mit dem doppelt Pointer würde mich trotzdem interessieren auch wenn es schlechter Still ist.