Hilfe

[eric93]

Hallo Leute,

bin neu hier und hoffe mal auf Hilfe.
Ich bin Student und wir haben derzeit eine Aufgabe die wir lösen müssen. Nur leider habe ich ein Problem bei einem folgenden C++ Programm.
Das Programm lässt sich öffnen, aber sobald ich bei dem Programmpunkt (4) Daten eingeben möchte, stürzt das Programm DevC++ ab.

Kann mir da jemand helfen?

// telefonbuch-14.06.2017.cpp : Definiert den Einstiegspunkt für die Konsolenanwendung.
//

#include <string>
#include <iostream>
#include <fstream>
using namespace std;
//-----------------------------------------------------------------------------
class convertstring
{
public: static string UPCASE(string Text)
{
			for (unsigned int i = 0; i<Text.length(); i++)
			{
				if ((Text.at(i) >= 'a') && (Text.at(i) <= 'z'))
					Text.at(i) -= ('a' - 'A');
			}
			return (Text);
}
};
//--------------------------------------- Klassendefinition Person ------

class Person 
{
protected: string Name;
protected: string Vorname;
protected: string Telefonnummer;
protected: string EMAIL;

public: Person(void)
{
			this->Name = "-";
			this->Vorname = "-";
			this->Telefonnummer = "-";
			this->EMAIL = "-";
}
public: void set(string Name, string Vorname, string Telefon, string Email)
{
			this->Name = Name;
			this->Vorname = Vorname;
			this->Telefonnummer = Telefon;
			this->EMAIL = Email;
}
public: string get(void)
{
			string ausgabe;
			ausgabe = Name + ", " + Vorname + ", "
				+ Telefonnummer + ", " + EMAIL;
			return (ausgabe);
}
public: string get_fields(void)
{
			string ausgabe;
			ausgabe = Name + " " + Vorname + " "
				+ Telefonnummer + ", " + EMAIL;
			return (ausgabe);
}
public: string getName(void)
{
			return(Name);
}
public: string getVorname(void)
{
			return(Vorname);
}
		//-------------------------------------------- operator> ---------------------
public: int operator> (Person& Persondata)  // überladener Operator >
{
			if (convertstring::UPCASE(Name) >
				convertstring::UPCASE(Persondata.Name))
			{  // cout<<"compare NN = 1";
				return (1);
			}
			else
			{
				if ((convertstring::UPCASE(Name) ==
					convertstring::UPCASE(Persondata.Name)) &&
					(convertstring::UPCASE(Vorname) >
					convertstring::UPCASE(Persondata.Vorname)))
				{   //cout<<"compare VN = 1";
					return (1);
				}
			}
			//cout<<"compare = 0";
			return (0);
}
		//-------------------------------------------- operator< ---------------------
public: int operator< (Person& Persondata)  // überladener Operator <
{
			if (convertstring::UPCASE(Name) <
				convertstring::UPCASE(Persondata.Name))
			{  // cout<<"compare NN = 1";
				return (1);
			}
			else
			{
				if ((convertstring::UPCASE(Name) ==
					convertstring::UPCASE(Persondata.Name)) &&
					(convertstring::UPCASE(Vorname) <
					convertstring::UPCASE(Persondata.Vorname)))
				{   //cout<<"compare VN = 1";
					return (1);
				}
			}
			//cout<<"compare = 0";
			return (0);
}

};
//--------------------------------------- Klassendefinition node --------
class node
{
public: node* next;
public: Person* Persondata;
public: node(void)   // Konstruktor
{
			this->Persondata = new (Person); // Datensatz für eine Person
			// erzeugen
			this->next = NULL;
}
public: ~node(void)
{
			delete (this->Persondata);
}
};
//------------------------------------------------- Knotenliste -------
// Für jeden Anfangsbuchstaben 'A' bid 'Z' wird die Adresse
// des ersten Knotens für die Personen mit diesem Buchstaben abgespeichert.
// Dies ermöglicht schnellere Sortier- und Suchvorgänge

class clsKnotenListe
{
private: node* KnotenX[26];
public: clsKnotenListe(void)
{
			for (int i = 0; i < 26; i++) KnotenX[i] = NULL;
}
public: void set_KnotenX(char X, node* K)
{
			if (X >= 'a') X -= 'a' - 'A'; // Kleinbuchstaben in 
			// Großbuchstaben umwandeln
			KnotenX[X - 'A'] = K;
}
public: node* get_KnotenX(char X)
{
			if (X >= 'a') X -= 'a' - 'A'; // Kleinbuchstaben in 
			// Großbuchstaben umwandeln
			return (KnotenX[X - 'A']);

}
};

	// Klassendefinition von Datum

class Datum 
{
private: int Tag;
private: int Monat;
private: int Jahr;

public: Datum(void);

public: bool input();
public: void set();
public: void get();

public: bool operator> (Datum D);

};

//---------------------------- Klassendefinition verketteteListe --------
class verketteteListe : public Person
{
private: node* first;
private: clsKnotenListe KnotenListe;
public: verketteteListe(void)   // Konstruktor
{
			this->first = NULL;
}
		// Methode check_EMAIL

public: bool check_EMAIL(string EMAIL)
{
			string email = EMAIL;
			int count = 0;
			bool punkt = false;
			unsigned int laenge = email.length();

			if (email != "")
			{

				for (unsigned int i = 0; i < email.length(); i++)
				{
					if (email.at(i) == '.' && email.at(i + 1) == '.')
					{
						punkt = true;
					}

					else if (email.at(i) == '@')
					{
						count++;
					}
				}

				if (punkt == false && count == 1 && email.at(0) != '.' && email.at(laenge) != '.')
				{
					cout << "Richtiges Format." << endl;
					return true;
				}
				else
				{
					cout << "Falsches Format." << endl;
					return false;
				}

			}
}

		//------------------------------------- Liste_ausgeben() -------------------

public: void Liste_ausgeben(void)
{

			if (this->first == NULL)
			{
				cout << "------------------------------------" << endl;
				cout << "--- Liste leer! -------" << endl;

			}
			else
			{
				node* currentnode;
				cout << "----------------------------------------" << endl;
				cout << "-------------- Liste ausgeben ----------" << endl;
				currentnode = this->first;
				while (currentnode != NULL)
				{
					cout << currentnode->Persondata->get() << endl;
					currentnode = currentnode->next;
				}
			}
			cout << "----------------------------------------" << endl;
}
		//--------------------------------------------------------------------
public: void  Datensatz_anhaengen(string Name, string Vorname,
	string Telefon, string Email)
{
			node* newnode = new (node);	//neuer Knoten 
			//mit Persondata->Datensatz
			newnode->Persondata->set(Name, Vorname, Telefon, Email);
			node* currentnode;
			if (this->first == 0) // Liste noch leer
			{
				this->first = newnode;
			}
			else
			{
				currentnode = this->first;
				// Ende der Liste suchen
				while (currentnode->next != NULL)
				{
					currentnode = currentnode->next;
				}
				// currentnode zeigt jetzt auf den letzten Datensatz
				currentnode->next = newnode;
			}
}
		//------------------------------- Demo_liste ----------------------------------
public: void Demo_Liste(void)
{
			cout << "--------- Demoliste erstellen ---------" << endl;
			Datensatz_anhaengen("Amsel", "Anne", "(+49)7989/478", "st@web.de");
			Datensatz_anhaengen("Spatz", "Sebastian", "022/454547", "j-n@gmx.de");
			Datensatz_anhaengen("Zeisig", "Anton", "033/42254-678", "lucos@web.de");
			Datensatz_anhaengen("Elster", "Elise", "033/42254-679", "elise@t-online.de");
			Datensatz_anhaengen("Elster", "Elise", "033/42254-679", "-");
			Datensatz_anhaengen("Spatz", "Sabine", "022/4545-4678", "kuschelhase@web.de");
}
		//--------------------------- Neuer_Eintrag(void) --------------------
public: void Neuer_Eintrag(void)
{
			string Name, Vorname, Telefon, Email;
			cout << "Name: "; cin >> Name;
			cout << "Vorname: "; cin >> Vorname;
			cout << "Telefon: "; cin >> Telefon;

			do
			{
				cout << "E-Mail: "; cin >> Email;
			} while (!check_EMAIL(Email) == true);

			if (check_EMAIL(Email) == true)
			{
				Datensatz_anhaengen(Name, Vorname, Telefon, Email);
				cout << "----------------------------------------" << endl;
				cout << "Datensatz angehaengt: " << Name << ", " << Vorname
					<< ", " << Telefon << Email << endl;

				cout << "----------------------------------------" << endl;
			}
}

		//------------------------------- Liste_loeschen -----------------------------
public: void Liste_loeschen(void)
{
			cout << "----------------------------------------------" << endl;
			if (this->first == NULL)
			{
				cout << "liste leer!" << endl;
			}
			else
			{
				node* currentnode = NULL;
				node* oldnode = NULL;
				currentnode = this->first;
				while (currentnode != NULL)
				{
					oldnode = currentnode;
					currentnode = currentnode->next;
					delete (oldnode);
				}
				cout << "Liste geloescht!" << endl;
				this->first = NULL;
			}
			cout << "--------------------------------------------" << endl;
}
		//----------------------------------------- Eintrag suchen -----------
public: void Eintrag_suchen(void)
{
			string Suchname;
			int count = 0;
			cout << "----------  Eintraege nach Name suchen ----" << endl;
			cout << "Name: "; cin >> Suchname;
			if (this->first == 0)
			{
				cout << "liste leer!" << endl;
			}
			else
			{
				node* currentnode;
				currentnode = this->first;
				// Alle Datensätze durchlaufen
				while (currentnode != NULL)
				{
					if (convertstring::UPCASE
						(currentnode->Persondata->getName())
						== convertstring::UPCASE(Suchname))
					{
						count++;
						cout << count << ": " << currentnode->
							Persondata->get() << endl;
					}
					currentnode = currentnode->next;
				} // while 
			} // if()else
			if (count == 0)
			{
				cout << "--- keine Eintraege gefunden! -------" << endl;
			}
			else
			{
				cout << "------- " << count << " gefunden! --------" << endl;
			}
}

		//------------------------------ tausche () ---------------------------
private: void tausche(node* ZnodeA, node* ZnodeB)
{
			 Person* tempPersondata;
			 tempPersondata = ZnodeA->Persondata;
			 ZnodeA->Persondata = ZnodeB->Persondata;
			 ZnodeB->Persondata = tempPersondata;
}
		 //------------------------------ Liste_sortieren ----------------------
public: void Liste_sortieren(void)
{

			cout << "----------------------------------------------" << endl;
			if (this->first == NULL)
			{
				cout << "liste leer!" << endl;
			}
			else
			{
				int vertauscht;
				node* currentnode;
				do {
					vertauscht = 0;
					currentnode = this->first;
					while (currentnode->next != NULL)
					{
						if ((*currentnode->Persondata)>
							(*currentnode->next->Persondata))
						{ // Zeiger auf Personendaten tauschen
							tausche(currentnode, currentnode->next);
							vertauscht = 1;
						}
						currentnode = currentnode->next;
					}  // of while 
					// Liste_ausgeben();
				} while (vertauscht == 1); // end of do 
				cout << "Liste sortiert!" << endl;
			}  // end of  if()else 
			cout << "----------------------------------------------" << endl;
}
		//------------------------------ neuer_Eintrag_einsortieren() --------
private: void Datensatz_einsortieren(string Name, string Vorname, string Telefon, string Email)
{
			 node* newnode = new (node); 	//neuer Knoten 
			 // mit Persondata->Datensatz

			 newnode->Persondata->set(Name, Vorname, Telefon, Email);
			 //--------------------------------------
			 // Fallunterscheidungen:
			 if (this->first == 0)              // 1. Liste noch leer
			 {
				 this->first = newnode;
			 }
			 else
			 {
				 node* currentnode;
				 int eingetragen = 0;
				 currentnode = this->first;
				 if ((*newnode->Persondata)<
					 (*currentnode->Persondata))
				 {                       // 2. neuer Datensatz 
					 //    VOR dem 1. Knoten
					 newnode->next = currentnode;
					 this->first = newnode;
					 eingetragen = 1;
				 }
				 else
				 {                     // 3. bis zum Ende 
					 // der Liste vergleichen
					 while (currentnode->next != NULL)
					 {
						 if ((*newnode->Persondata) >
							 (*currentnode->next->Persondata))
							 // weiter zum naechsten
						 {
							 currentnode = currentnode->next;

						 }
						 else
						 {// zwischen currentnode 
							 // und currentnode->next
							 // eintragen
							 newnode->next = currentnode->next;
							 currentnode->next = newnode;
							 eingetragen = 1;
							 break;
						 }
					 }
				 }
				 if ((eingetragen == 0) &&
					 (currentnode->next == NULL))
				 {      // 4. an den letzten anhaengen
					 currentnode->next = newnode;
				 }
			 }
}
		 //------------------------------------- neuer_Eintrag_einsortieren(); ---
public: void neuer_Eintrag_einsortieren(void)
{
			string Name, Vorname, Telefon, Email;
			cout << "Name: "; cin >> Name;
			cout << "Vorname: "; cin >> Vorname;
			cout << "Telefon: "; cin >> Telefon;
			cout << "Email: "; cin >> Email;
			Datensatz_einsortieren(Name, Vorname, Telefon, Email);
			cout << "----------------------------------------" << endl;
			cout << "Datensatz einsortiert: " << Name << ", " << Vorname
				<< ", " << Telefon << Email << endl;
			cout << "----------------------------------------" << endl;
}
		//--------------------------------------- Eintrag_loeschen() ----
public: void Eintrag_loeschen(void)
{

			cout << " ---- Eintrag loeschen ----" << endl;
			if (this->first == 0)                   //  Liste ist leer
			{
				cout << " ---- Liste leer!!! ------" << endl;
			}
			else
			{
				string Name, Vorname;
				node* currentnode;
				node* oldnode = NULL;
				int gefunden = 0;
				cout << "Name: "; cin >> Name;
				cout << "Vorname: "; cin >> Vorname;
				currentnode = this->first;
				while (currentnode != NULL)
				{
					if ((currentnode->Persondata->getName() == Name)
						&&
						(currentnode->Persondata->getVorname() ==
						Vorname))
					{
						cout << "Eintrag gefunden: " <<
							currentnode->Persondata->get() << endl;;
						gefunden = 1;
						cout << "Eintrag wird geloescht!" << endl;
						if (currentnode == this->first)
							// erster Eintrag
						{
							this->first = currentnode->next;
						}
						else
						{
							oldnode->next = currentnode->next;
						}
						delete (currentnode);
						break;
					}
					oldnode = currentnode;
					currentnode = currentnode->next;
				}
				if (gefunden != 1)
					cout << "Name nicht gefunden!" << endl;
			}
}
		//----------------------------------------- TelefonBuch speichern ----
#define Dateiname "Telefonbuch_Daten.txt"
public: void TelefonBuch_speichern(void)
{
			ofstream Ausgabedatei(Dateiname, ios::out);
			node* currentnode;
			if (Ausgabedatei.good())
			{
				cout << "----------------------------------------------" << endl;
				cout << Dateiname << " konnte geoeffnet werden!" << endl;
				cout << "----------------------------------------------" << endl;
				if (this->first == NULL)
				{
					cout << "----------------------------------------" << endl;
					cout << "--- Liste leer! -------" << endl;
					cout << Dateiname << " wird leer beschrieben!" << endl;
				}
				else
				{
					cout << "----------------------------------------" << endl;
					cout << "-------------- Liste ausgeben ----------" << endl;
					currentnode = this->first;
					while (currentnode != NULL)
					{
						cout << currentnode->Persondata->get_fields() << endl;
						Ausgabedatei << currentnode->Persondata->get_fields()
							<< endl;
						currentnode = currentnode->next;
					}
				}
				cout << "Ausgabedatei schliessen." << endl;
				Ausgabedatei.close();
				cout << "----------------------------------------" << endl;
			}
			else
			{
				cout << "-------------------------------------------------" << endl;
				cout << "Fehler bei Oeffnen der Datei " << Dateiname << "!" << endl;
				cout << "-------------------------------------------------" << endl;
			}
}

		//--------------------------------------- TelefonBuch_einlesen(); --------
public: void TelefonBuch_einlesen(void)
{
			ifstream Eingabedatei(Dateiname, ios::in);
			string Name, Vorname, Telefon, Email;
			int count = 0;
			if (Eingabedatei.good())
			{
				cout << Dateiname << " konnte geoeffnet werden!" << endl;
				while (!Eingabedatei.eof()) // bis 'end of file' EOF
				{
					Name = "";
					Eingabedatei >> Name;
					Eingabedatei >> Vorname;
					Eingabedatei >> Telefon;
					Eingabedatei >> Email;
					if (Name != "")
					{
						Datensatz_anhaengen(Name, Vorname, Telefon, Email);
						count++;
					}
				}
				cout << "Es wurden " << count << " Datensaetze gelesen!" << endl;
				cout << Dateiname << " schliessen." << endl;
				Eingabedatei.close();
			}
			else
			{
				cout << "-----------------------------------------------------" << endl;
				cout << "Fehler bei Oeffnen der Datei " << Dateiname << "!" << endl;
				cout << "-----------------------------------------------------" << endl;
			}
}
		// ---------------------------------  KnotenListe verwalten -------------
		// ----------------------------------- KnotenListe aktualisieren --------
public: void KnotenListe_aktualisieren(void)
{
			cout << "KnotenListe aktualisieren... " << endl;
			if (this->first == 0)  // Wenn keine Einträge,
				// KnotenListe löschen
			{
				for (int i = 'A'; i <= 'Z'; i++)
					KnotenListe.set_KnotenX(i, NULL);
			}
			else
			{
				node* currentnode = this->first;
				for (int i = 'A'; i <= 'Z'; i++)
					KnotenListe.set_KnotenX(i, currentnode);
				char oldletter = 'A', newletter;
				while (currentnode != NULL)
				{   // Anfangsbuchstabe der Person ermitteln:
					newletter = convertstring::UPCASE(currentnode->Persondata->getName()).at(0);
					if (newletter != oldletter)
					{ // neuer Anfangsbuchstabe gefunden
						// alle folgende Knotenadressen auf diesen Knoten setzen 
						for (int i = newletter; i <= 'Z'; i++)
							KnotenListe.set_KnotenX(i, currentnode);
						oldletter = newletter;
					}
					currentnode = currentnode->next;
				}
			}
}
		//------------------------------------------- KnotenListe ausgeben ------
public: void KnotenListe_ausgeben(void)
{
			cout << "KnotenListe ausgeben." << endl;
			cout << " first = " << this->first << endl;
			for (char i = 'A'; i <= 'Z'; i++)
			{
				node* aktnode = KnotenListe.get_KnotenX(i);
				if (aktnode == NULL)
				{
					cout << i << ": " << aktnode << " " << endl;
				}
				else
				{
					cout << i << ": " << aktnode << " " <<
						aktnode->Persondata->getName() << endl;
				}
			}
}

public: void Doppelte_Eintraege_loeschen(void)
{
			if (this->first == NULL)
			{
				cout << "Liste leer!" << endl;
			}
			else
			{
				node* currentnode = this->first;
				node* oldnode = NULL;
				while (currentnode->next != NULL)
				{   // Vergleich von Vor- und Nachname von zwei aufeinanderfolgenden Datensaetzen
					if ((convertstring::UPCASE(currentnode->Persondata->getName()) ==
						convertstring::UPCASE(currentnode->next->Persondata->getName()))
						&&
						(convertstring::UPCASE(currentnode->Persondata->getVorname()) ==
						convertstring::UPCASE(currentnode->next->Persondata->getVorname())))
					{
						cout << "doppelter Datensatz: " << currentnode->Persondata->get() << endl;
						cout << "Datensatz wird geloescht!" << endl;
						oldnode = currentnode->next;         // einen Datensatz aus der Kette entfernen
						currentnode->next = currentnode->next->next;
						delete (oldnode);
					}
					else
					{
						currentnode = currentnode->next;
					}
				}
			}

}
		//-------------------------------------- Anzahl der Datensätze ----------
public: void Anzahl_Datensaetze(void)
{
			int count = 0;
			cout << "----------  Anzahl der Einträge -------" << endl;
			if (this->first == 0)
			{
				cout << "liste leer!" << endl;
			}
			else
			{
				node* currentnode;
				currentnode = this->first;
				// Alle Datensätze durchlaufen
				while (currentnode != NULL)
				{
					count++;
					currentnode = currentnode->next;
				}  // while 
			} // if()else

			cout << "Anzahl: " << count << endl;
			cout << "---------------------------------------" << endl;
}
		//--------------------------------------------- Datensatz_suchen_2 ------
private: node* Datensatz_suchen_2(void)
{
			 string Nachname, Vorname;
			 cout << "---------- Eintrag nach Name und Vorname suchen ----" << endl;
			 cout << "Nachname: "; cin >> Nachname;
			 cout << "Vorname: "; cin >> Vorname;
			 if (this->first == 0)
			 {
				 cout << "liste leer!" << endl;
				 return (NULL);
			 }
			 else
			 {
				 node* currentnode;
				 currentnode = this->first;
				 // Alle Datensätze durchlaufen
				 while (currentnode != NULL)
				 {
					 if ((convertstring::UPCASE
						 (currentnode->Persondata->getName())
						 == convertstring::UPCASE(Nachname))
						 &&
						 (convertstring::UPCASE
						 (currentnode->Persondata->getVorname())
						 == convertstring::UPCASE(Vorname)))
					 {
						 return (currentnode);
					 }
					 currentnode = currentnode->next;
				 } // while 
			 } // if()else

			 cout << "--- keine Eintraege gefunden! -------" << endl;
			 return (NULL);
}
		 //--------------------------------------------- Datensatz editieren -----
public: void Datensatz_editieren()
{
			node* current_node;
			current_node = Datensatz_suchen_2();
			if (current_node != NULL)
			{
				cout << ": " << current_node->
					Persondata->get() << endl;
				string Telefon, Nachname, Vorname, Email;
				Nachname = current_node->Persondata->getName();
				Vorname = current_node->Persondata->getVorname();
				cout << "Neue Telefonnummer: "; cin >> Telefon;
				current_node->Persondata->set(Nachname, Vorname, Telefon, Email);
				cout << "Datensatz geaendert: ";
				cout << current_node->Persondata->get() << endl;
			}
			else
			{
				cout << "Abbruch: Datensatz nicht gefunden" << endl;

			}
			cout << "---------------------------" << endl;
}
		//---------------------------------------- suchen mit knotenliste -------
public: void suchen_mit_Knotenliste(void)
{
			string Suchname;
			int count = 0;
			cout << "----------  Eintraege nach Name mit Knotenliste suchen ----" << endl;
			cout << "Name: "; cin >> Suchname;
			Suchname = convertstring::UPCASE(Suchname);
			if (this->first == 0)
			{
				cout << "liste leer!" << endl;
			}
			else
			{
				node* currentnode;
				//currentnode = this->first;
				char Buchstabe;
				Buchstabe = Suchname.at(0);
				currentnode = KnotenListe.get_KnotenX(Buchstabe);
				// Alle Datensätze durchlaufen
				while ((currentnode != NULL)
					&&
					(convertstring::UPCASE
					(currentnode->Persondata->getName()).at(0) == Buchstabe))
					// Es wird nur der Bereich durchsucht mit dem Anfangsbuchstaben
					// vom Suchnamen
				{
					if (convertstring::UPCASE
						(currentnode->Persondata->getName())
						== convertstring::UPCASE(Suchname))
					{
						count++;
						cout << count << ": " << currentnode->
							Persondata->get() << endl;
					}
					currentnode = currentnode->next;
				} // while 
			} // if()else
			if (count == 0)
			{
				cout << "--- keine Eintraege gefunden! -------" << endl;
			}
			else
			{
				cout << "------- " << count << " gefunden! --------" << endl;
			}
}

		//-----------------------------------------------------------------------
}; // end of class verketteteListe
//-----------------------------------------------------------------------
int main(void)
{
	verketteteListe* TelefonBuch = new (verketteteListe);
	// TelefonBuch ist ein Zeiger auf den "Kopf" der Liste
	//----------------------------  Eingabemenue --------------------
	int Auswahl;
	do {
		cout << "*********** Telefonliste ***************" << endl;
		cout << "  0: Ende" << endl;
		cout << "  1: Liste loeschen" << endl;
		cout << "  2: Demoliste" << endl;
		cout << "  3: Liste ausgeben" << endl;
		cout << "  4: Neuer Eintrag" << endl;
		cout << "  5: Eintrag loeschen" << endl;
		cout << "  6: Liste sortieren" << endl;
		cout << "  7: Eintrag sortiert einhaengen!" << endl;
		cout << "  8: Eintrag suchen" << endl;
		cout << " 10: Aufgabe: TelefonBuch speichern" << endl;
		cout << " 11: Aufgabe: TelefonBuch einlesen" << endl;
		cout << " 12: Doppelte Einträge loeschen" << endl;
		cout << " 15: KnotenListe aktualisieren" << endl;
		cout << " 16: KnotenListe ausgeben" << endl;
		cout << " 17: Anzahl der Datensaetze" << endl;
		cout << " 18: Datensatz editieren" << endl;
		cout << " 19: Datensaetze suchen ueber Knotenliste" << endl;
		cout << "                    Auswahl: ";
		cin >> Auswahl;
		switch (Auswahl)
		{
		case 0: cout << "...auf Wiedersehen!" << endl;
			break;
		case 1: TelefonBuch->Liste_loeschen();
			break;
		case 2: TelefonBuch->Demo_Liste();
			break;
		case 3: TelefonBuch->Liste_ausgeben();
			break;
		case 4: TelefonBuch->Neuer_Eintrag();
			break;
		case 5: TelefonBuch->Eintrag_loeschen();
			break;
		case 6: TelefonBuch->Liste_sortieren();
			break;
		case 7: TelefonBuch->neuer_Eintrag_einsortieren();
			break;
		case 8: TelefonBuch->Eintrag_suchen();
			break;
		case 10: TelefonBuch->TelefonBuch_speichern();
			break;
		case 11: TelefonBuch->TelefonBuch_einlesen();
			break;
		case 12: TelefonBuch->Doppelte_Eintraege_loeschen();
			break;
		case 15: TelefonBuch->KnotenListe_aktualisieren();
			break;
		case 16: TelefonBuch->KnotenListe_ausgeben();
			break;
		case 17: TelefonBuch->Anzahl_Datensaetze();
			break;
		case 18: TelefonBuch->Datensatz_editieren();
			break;
		case 19: TelefonBuch->suchen_mit_Knotenliste();
			break;
		default: cout << "ungueltige Auswahl!" << endl;
			break;
		}
	} while (Auswahl != 0);
	return 0;
}

Vielen Dank, falls mir jemand helfen kann

Grüße
Eric

[Schlangenmensch]

Hi,

versuche dein Programm so zu reduzieren, dass es minimal wird. Hier werden wenige Lust haben 800 Zeilen Code zu lesen und sich zu überlegen was wohl Programm Punkt 4 sein mag.

Prinzipiell aber musst du private und public nicht vor jede Variable oder Funktion schreiben. Die Schlüsselwörter kennzeichnen einen Bereich und gelten dann für alles nachfolgende, bis dann ein anderer Bezeichner kommt.

Außerdem ist es ratsam Deklaration und Definition zu trennen, in Header und Source Dateien. Auch eine Trennung von verschiedenen Klassen in verschiedene Dateien ist zu empfehlen für mehr Übersicht.

Wahrscheinlich stürzt auch dein Programm ab und nicht deine Entwicklungsumgebung. Und da wäre die Fehlermeldung interessant. Ich würde darauf Tippen, dass du in nicht reservierten Speicherbereich schreiben willst, aber genauer guck ich erst wenn das Beispiel reduziert ist.

[wob]

Nur generelle Kommentare, aber dafür ganz viele. Habe keine Lust, in dem unübersichtlichen Programm einen Fehler zu suchen. Bau diese Kommentare ein und mach dann ein Minimalbeispiel, das deinen Fehler zeigt.

Hier also meine Ergüsse:

- es gibt std::toupper und std::tolower , um einzelne Zeichen in Groß- bzw. Kleinschreibung umzuwandeln. Dementsprechend ist c = toupper(c) auch leichter zu lesen als das Subtrahieren von ('a'-'A') . Und für ganze Strings könntest du auch boost::to_upper(str) bzw boost::to_upper_copy(str) aus boost/algoritm/string.hpp verwenden.

- dein Code sieht aus wie von einem Java-Programmierer, der C kennt und beides dann auf C++ anwendet... Konkret: ständiges Wiederholen des Gültigkeitsbereiches und die Klasse convertstring mit einer einzigen statischen Funktion. Wozu soll das dann eine Klasse sein, von der man eine Insanz erzeugen kann? Außerdem: wenn eine Funktion keine Argumente nimmt, dann einfach f() statt f(void) . Letztes ist C ohne ++. Die Klammern bei new und return gehören da ebenfalls nicht hin. Bei new denkt man dann an placement new und bei return daran, dass jemand vielleicht decltype(auto) benutzt hat und nun einen anderen Returntyp will. Also: per default die Klammern bei new+return einfach weglassen.

- Dann nutze große Anfagsbuchstaben für deine Klassen. Also Node . Dann kann man eine Node-Variable nämlich einfach node nennen.

- Brauchst du all die Operatorüberladungen? Ich würde operator< überladen und operator== . Die anderen kannst du dann durch Benztzung dieser beiden erzeugen. Der Grund dafür ist Konvention, z.B. wird operator< bei maps vorausgesetzt wird. operator> kannst du dann so implementieren:

bool operator>(const Person& lhs, const Person& rhs) { 
    return rhs < lhs;
}

>= kann man aus nicht < erzeugen usw.

- Deine Vererbung ist merkwürdig:
eine verketteteListe ist eine Person?! Das klingt schon falsch. So sollte man Vererbung nicht nutzen. Ebenso: check_EMAIL ist bei dir eine Funktion der verketteten Liste. Eine Klasse sollte nur für eine Sache zuständig sein. Eine verkettete Liste kann darf also keine E-Mail-Adressen prüfen können!

- Probiere gerne die ganze Speicherverwaltung mit new+delete aus. Aber versuche dann mal das ganze mit std::unique_ptr zu machen. Wenn man nämlich von Hand Speicher verwaltet, ist das immer extrem fehleranfällig. Daher kann dir std::unique_ptr bestimmt weiterhelfen. Alternativ implementiere das ganze mit einem std::vector statt einer verketteten Liste. Das ist einfacher und sehr wahrscheinlich auch schneller.

- Da ist bestimmt noch viel mehr zu kritisieren... Aber nimm diese Dinge erstmal als Anhaltspunkt.

Die vielen Edits bin zu doof, richtig zu schreiben bzw. die Fehler vorher zu finden...

[camper]

eric93 schrieb:

Das Programm lässt sich öffnen, aber sobald ich bei dem Programmpunkt (4) Daten eingeben möchte, stürzt das Programm DevC++ ab.

Wenn DevC++ abstürzt, dürfte DevC++ fehlerhaft sein, Was hat das mit deinem Programm zu tun?

[tzjgne4tg]

Ich hätte da mal ein paar Fragen:
Von wem hast du den Code denn geklaut? Es ist vielleicht nicht stilvoll programmiert, aber wer auch immer das programmiert hat sollte relativ schnell herausfinden wieso das Programm abstürzt...

[Furble Wurble]

Habs mal ausprobiert.

bool check_EMAIL(string EMAIL)
{
            string email = EMAIL;
            int count = 0;
            bool punkt = false;
            unsigned int laenge = email.length();

            if (email != "")
            {

                for (unsigned int i = 0; i < email.length(); i++)
                {
                    if (email.at(i) == '.' && email.at(i + 1) == '.')
                    {
                        punkt = true;
                    }

                    else if (email.at(i) == '@')
                    {
                        count++;
                    }
                }

                if (punkt == false && count == 1 && email.at(0) != '.' && email.at(laenge) != '.')
                {
                    cout << "Richtiges Format." << endl;
                    return true;
                }
                else
                {
                    cout << "Falsches Format." << endl;
                    return false;
                }

            }
}

Du darfst string::at nur mit *Indices < string::length *aufrufen.
Was gibt die Funktion zurück, wenn die Bedingung in Z. 8 nicht erfüllt ist?

[Jockelx]

bool check_EMAIL(string EMAIL)
{
            string email = EMAIL;
...

Ich würde vorsichtshalber noch ne 3te Kopie anlegen