ich mache gerade eine Aufgabe und habe es eigentlich bis auf eine Teilaufgabe fertig. Das Programm kompiliert aber danach stürzt es ab. Die Aufgabe besteht aus mehreren Teilen. Ich schreibe hier mal die komplette Aufgabe, damit es verständlich ist.

Ergänzen Sie den unten angegebenen Code wie beschrieben, um eine ablauffähige, korrekte Version zu erhalten. Korrekt bedeutet insbesondere, dass die Fälle der Initialisierung einer Variablen vom Typ PFeld bei der Deklaration, die Wertzuweisung an eine Variablen vom Typ PFeld und die Vernichtung einer Variablen vom Typ PFeld korrekt funktionieren. Siehe dazu auch das unten gegebene Hauptprogramm. Denken sie an die notwendigen Konstruktoren, den Destruktor und den Zuweisungsoperator.

a) Ergänzen Sie die gegebene Klassendefinition von PFeld. Fügen Sie geeigneten Code für den parameterbehafteten Konstruktor ein.
b) get() und set() Funktion definieren.
c) Kopierkonstruktor definieren.
d) Zuweisungsoperator überladen.
e) Überladen Sie den Bitshiftoperator << für die Ausgabe einer Variablen vom Typ Punkt auf der Standardausgabe. Die Ausgabe eines Punktes mit x=5.5, y=6.6 z. B. soll folgendermaßen aussehen: (5.5,6.6)
f) Überladen Sie den Feldindexoperator [] für PFeld, d.h. ermöglichen Sie die Feldindexschreibweise für Objekte vom Typ PFeld. Führen Sie eine Indexprüfung durch und brechen Sie das Programm bei einem ungültigen Index ab.

Bis auf die Aufgabe f habe ich versucht alles zu machen. Ich erwarte nicht, dass hier jemand für mich die Aufgabe macht. Ich will wissen, wieso das Programm abstürzt. Ich würde mich aber freuen, wenn jemand die Aufgabe kurz durchgeht und schaut, ob ich alles richtig gemacht habe.

#include <iostream>
using namespace std;

struct Punkt {
	double x;
	double y;
};

class PFeld { //In dieser Klasse wird dynamisch Speicher allokiert

	Punkt *pp;
	int dim;

public:
	// Standardkonstruktor
	PFeld() {
		pp = 0;
		dim = 0;
	}

	// Kopierkonstruktor
	PFeld(const PFeld &copy) {
		for (int i = 0; i < dim; i++) {
			this->pp[i].x = copy.pp[i].x;
			this->pp[i].y = copy.pp[i].y;
		}
	}

	// hier Code eintragen, alle Punkte werden auf 0
	// initialisiert, d.h. die Elementvariablen x, y werden für jeden
	// Punkt auf 0 gesetzt.
	PFeld(int d) {
		for (int i = 0; i < d; i++) {
			pp[i].x = 0;
			pp[i].y = 0;
		}	
	}

	// hier Code eintragen
	~PFeld() {
		delete pp;
	}

	//i-tes Punkt Element aus PFeld wird zurückgegeben
	Punkt get(int i) {
		return pp[i];
	}

	// Element x, y des Punktes
	// an der Stelle i setzen
	void set(int i, double x, double y) {
			pp[i].x = x;
			pp[i].y = y;	
	}

	// Deklaration Zuweisungsoperator
	PFeld& PFeld::operator=(PFeld const& ob2);

	// Deklaration Bitshiftoperator
	friend ostream& operator<<(ostream& os, PFeld p);

	// Deklaration Feldindexoperator
	//PFeld& PFeld::operator[](PFeld const& ob2);

}; //Ende Klassendefinition PFeld

// Bitshiftoperator
ostream& operator<<(ostream& out, Punkt p) {
	return out << '(' << p.x << ',' << p.y << ')' << endl;
}

// Zuweisungsoperator
PFeld& PFeld::operator=(PFeld const& ob2) {
	for (int i = 0; i < dim; i++) {
		this->pp[i].x = ob2.pp[i].x;
		this->pp[i].y = ob2.pp[i].y;
	}
	return *this;
}

int main() {
	const int pdim = 10;
	PFeld einPFeld(pdim); // Aufruf Parameterkonstruktor
	PFeld zweitesPFeld;
	int i;

	// Initialisierung von einPFeld
	for (i = 0; i < pdim; i++) {
		einPFeld.set(i, i + 0.5, i*2.0);
	}

	// weise Wert zu
	zweitesPFeld = einPFeld; // überladener Zuweisungsoperator aufgerufen
	//zweitesPFeld[0] = einPFeld; // Zugriff über Feldindex

	// Ausgabe von zweitesPFeld
	for (i = 0; i < pdim; i++) {
		cout << zweitesPFeld.get(i).x << zweitesPFeld.get(i).y << endl;
	}

	// weise Wert zu
	PFeld drittesPFeld = einPFeld; // hier wird der Kopierkonstruktor aufgerufen

	// Ausgabe von drittesPFeld
	for (i = 0; i < pdim; i++) {
		cout << drittesPFeld.get(i) << drittesPFeld.get(i).y << endl;
	}

	return 0;

}

Vielen Dank!

class PFeld { //In dieser Klasse wird dynamisch Speicher allokiert

Wo eigentlich?

// Standardkonstruktor
	PFeld() {
		pp = new Punkt;
		pp = 0;
		dim = 0;
	}
	// Parameterkonstruktor
	PFeld(int d) {
		pp = new Punkt;
		for (int i = 0; i < d; i++) {
			pp[i].x = 0;
			pp[i].y = 0;
		}	
	}

korrekt?

pp = new Punkt; 
pp = 0;

Da sind noch ganz viele andere Fehler drin.
z. Bsp.
Wo wird im CopyConstructor Speicher vereinbart.
Was genau macht dein Zuweisungsoperator wenn dein übergebenes Feld eine andere Größe hat als das Orginalfeld?

pp Zeigt jetzt auf Speicher für einen Punkt

pp = 0;

pp Zeigt jetzt auf nichts mehr. Du hast keinen Zeiger mehr für den zuvor anglegten Speicher, so dass Du ihn nicht mehr frei geben könntest => Memoryleak.

dim = 0;
	}
	// Parameterkonstruktor
	PFeld(int d) {
		pp = new Punkt;

pp Zeigt jetzt auf Speicher für einen Punkt. Ist d > 0 greift bereits der 2. Schleifendurchlauf auf Speicher zu, der Dir nicht gehört, was früher oder später zum Absturz führt.

for (int i = 0; i < d; i++) {
			pp[i].x = 0;
			pp[i].y = 0;
		}	
	}

Dann erkläre mal bitte was das hier bewirken soll

pp = new Punkt; 
pp = 0;

Da sind noch ganz viele andere Fehler drin.
z. Bsp.
Wo wird im CopyConstructor Speicher vereinbart.
Was genau macht dein Zuweisungsoperator wenn dein übergebenes Feld eine andere Größe hat als das Orginalfeld?

// Kopierkonstruktor
	PFeld(const PFeld &copy) {
		pp = new Punkt[copy.dim];
		for (int i = 0; i < dim; i++) {
			this->pp[i].x = copy.pp[i].x;
			this->pp[i].y = copy.pp[i].y;
		}
	}

Wie hier http://www.c-plusplus.net/forum/232010-full angegeben, habe ich die Zuweisung mit swap versucht aber ich bekomme eine Fehlermeldung "Keine Instanz von Überladene Funktion swap stimmt mit der Argumentliste überein. Argumenttypen sind: (PFeld)"

// Zuweisungsoperator
PFeld& PFeld::operator=(PFeld const& ob2) {
	if (this != &ob2)  
	{
		PFeld tmp(ob2);
		swap(tmp);
	}
	return *this;
}

...was früher oder später zum Absturz führt...

Wo soll ich das dann machen? Wie oben erwähnt, "In dieser Klasse wird dynamisch Speicher allokiert" war angegeben.

tntnet schrieb:

...was früher oder später zum Absturz führt...

Wo soll ich das dann machen? Wie oben erwähnt, "In dieser Klasse wird dynamisch Speicher allokiert" war angegeben.

Was genau war vorgegeben? Dass deine Konstruktoren, so wie du sie hier gepostet hast, vorgegeben waren, kann ich kaum glauben. Beim einen schmeißt du den Zeiger gleich ganz weg, beim anderen erzeugst du nur einen Punkt, wo du doch u.U. mehrere bräuchtest.

tntnet schrieb:

...was früher oder später zum Absturz führt...

Wo soll ich das dann machen?

Nicht nur für einen Punkt Speicher allozieren. Du weißt wie das geht, das seh ich an deinem zuletzt geposteten Kopierkonstruktor.

?

Du hast eine Frage gestellt (die in der Form, oder leicht abgeändert, jeder Programmierer auf der Welt jeden Tag öfters stellen könnte, er löst es aber dann doch selbst) und ignorierst im Prinzip die Antworten, fragst aber dann mit minimalen Verbesserungen nach, ob das jetzt passt.

So programmiert man nicht !
Weder im Beruf noch im Hobby noch in der Uni/Schule (denn du kannst ja in der Klausur auch keinen alle 30 Sekudnen fragen, ob das jetzt besser ist*).

Jetzt mal ernst beiseite: Ich denke, du willst nur mal eben das Fach bestehen und danach nicht mehr mit Programmierung in Berührung kommen? Aber auch dafür musst du ein bisschen tun.

*: Wenn doch, dann sag Bescheid, für so eine lächerliche Edukationseinrichtung gibts sicherlich viele Interessierten. Der Terminus "den Abschluss im lotto gewonnen haben" passt dahin sicherlich gut.

Welche Betriebssystem und welchen Editor und Compiler nutzt du?
Es gibt sogenannte Debugger. Damit kannst du Breakpoints im Sourcecode setzen und beim Ausführen hält dein Programm dort an und zeigt dir alle Variablen mit aktuellem Wert an. Da kannst du dann überprüfen, ob das stimmt was da zu sehen ist.

Für Windows kann ich Visual Studio mit seinem Debugger empfehlen, der ist echt einer der Besten, die es gibt (wie ich finde, der Compiler ist etwas verschrien hier im Forum).
Weiter reicht mein Horizont auch grad nicht, ausser einem Namen: gdb für Linux und den GCC Compiler.

Aber zu dem Thema werden dir hier andere noch weiter helfen können.

Also gut find ich das noch immer nicht. Wenn du ein Objekt mit dem Standardkonstruktor erstellst, gibt es kein new. Es gibt aber ein delete wenn es dann zerstört wird. Ein delete ohne new... (delete auf NULL ist zwar ok, aber trotzdem nicht schön)

Und wie willst du das "lösen"? Entweder im Standardkonstruktor noch ein sinnloses new, oder im Destruktor auf Null abfragen -- beides schlechtere Alternativen.