In einer Methode einer Klasse die Methode einer anderen Klasse aufrufen ?

Smuji

hmm....

und wie würde es richtig aussehen ?!?

Belli

Na, zB.:

Fachbereich objekt;

...

//Zugriff:
objekt.get_status() ... //anstelle von objekt->get_status()

Jockelx

Wobei Bellis Antwort nur den Kompilerfehler entfernt.
Unsinnig bleibt das trotzdem.

Fachbereich objekt;

if (objekt.get_status() == 1) {

Wer soll denn da auf wundersame weise den Status zwischen Zeile 1 und 3 geändert haben?

wob

Genau. Ich hatte in meinem letzten Post noch die Frage gestellt:

welcher Fachbereich soll das sein, es wurde keiner zugewiesen!

Diese Frage ist von dir bislang unbeantwortet. Was soll Fachbereich objekt denn sein? Ein generischer Fachbereich? Ein spezieller Fachbereich wie "Naturwissenschaften"?

Was soll objekt.get_status() denn zurückliefern?! Das bleibt alles völlig unklar. Wieso erzeugst du dort überhaupt einen Fachbereich? Du müsstest dir doch eigentlich irgendwie die Fachbereich-Liste von der Hochschule holen können.

Smuji

hey, erst nochmal vielen Dank für euren Einsatz.

Ich habe meinen Fehler gefunden.

Ich habe die ganze Zeit mit * und -> gearbeitet, weil mir auf die herkömmliche Art und Weise das Objekt immer rot unterstrichen wurde.
Ich konnte mir zwar nicht erklären, warum ich mit * und -> arbeite, aber das war die einzige Möglichkeit keinen roten Unterstrich zu bekommen.

Nun war ich mal 'ne viertel Stunde an der Luft und tadaa, Fehler gefunden...für Fachbereich gibt es keinen Standardkontruktor.

Warum ?!? Weil ich ihn iwann gelöscht habe. Vermutlich weil ich ihn nicht benutzt habe. Also habe ich den Standardkonstruktor wiederhergestellt und siehe da, es klappt.

Ich dachte, wenn ich einen anderen Konstruktor habe, bräuchte ich den Standardkonstruktor nicht mehr und kann ihn löschen, um es übersichtlicher zu machen. Falsch gedacht.

Nun ja, ich mach dann mal weiter. Ich bin mir sicher, ihr werden nochmal von mir hören

Smuji schrieb:

Ich dachte, wenn ich einen anderen Konstruktor habe, bräuchte ich den Standardkonstruktor nicht mehr und kann ihn löschen, um es übersichtlicher zu machen. Falsch gedacht.

Logischerweise kannst du nicht das löschen, was gebraucht wird.

wob

Smuji schrieb:

Ich habe meinen Fehler gefunden.

Du hast nur ein technisches Problem behoben. Die Frage bleibt immer noch, was der Code den eigentlich tun soll. Was soll das get_status bei einem default-konstuierten Fachbereich liefern? Und warum sollte es mal 1, mal 2 und mal noch was anderes ergeben?

Es bringt nichts, so lange den Code zu ändern, bis er kompiliert, solange du dir nicht endlich Gedanken machst, wie das alles zusammenhängen soll.

Smuji

also der code kompiliert schon. nur er funktioniert noch laaaaaange nicht

jetzt beginnt für mich erst das fehler ausmerzen bzw. das "in gang bringen".
nun kommt schon das erste problem.

ich habe in der klasse etwas wie:

class Fachbereich
{
	string bezeichnung;
	int studiengang = 0;
        ...

nun setzt mir meine einschreibmethode - > int studiengang = 1;

sobald die methode durchlaufen wurde und ich zurück in main() ankomme und mir dort zum test studiengang nochmal ausgebe, hat es wieder den wert = 0;

bleibt das nicht dauerhaft geändert ?

Ohne minimales, kompilierbares Codebeispiel schwer zu sagen, was du programmiert hast.

Smuji

ok, ich will euch eigentlich keine alpträume machen mit meinem code, aber ich poste mal alles was ich bisher so geschrieben habe.

p.s. beachtet nicht so die kommentare, die sind zum teil noch von vor tagen und falsch, diese wollte ich wenn ich fertig bin noch verändern.

auch muss ich überprüfen ob nicht ein paar methoden überflüssig sind....

MAIN

#include "Header.h"
#include "main.h"

/*Erstelle folgende Klassen: 

Hochschule (Container für deine Fachbereiche, Methoden zum Hinzufügen und Entfernen von Fachbereichen) 
Fachbereich (Container für Studiengänge, Methoden zum Hinzufügen und Entfernen von Studiengängen) 
Studiengang (der spezifische Studiengang, Methoden zum Einschreiben ...) 
Student

\201 => ü
\204 => ä
\224 => ö

*/

int main() {

	int auswahl = 0;
	int zähler = 0;
	Hochschule *objekt;
	Fachbereich hans; //test

	objekt = new Hochschule ("Technische Hochschule Mittelhessen");           // neue Hochschule erbaut

	Hochschule *thm[10];                                                                        // konstruktor NULL übergeben an beide werte und nur einer

	do {
		cout << objekt->get_name() << " - Studentenverwaltung:" << endl << endl;
		cout << "MENUE:" << endl << endl;
		cout << "\t 1 = In einen Studiengang einschreiben" << endl << endl;
		cout << "\t 2 = In einen Kurs einschreiben" << endl << endl;
		cout << "\t 3 = Noten des Kurses eintragen" << endl << endl;
		cout << "\t 4 = Ausgabe aller Studierenden" << endl << endl << endl;
		cout << "\t 5 = Nächster Student" << endl << endl << endl;
		cout << "Treffen Sie bitte jetzt Ihre Auswahl: " << endl << endl << endl;
		cin >> auswahl;
		cout << endl << endl << endl << endl << endl << endl << endl << endl << endl << endl << endl << endl << endl << endl << endl << endl << endl << endl << endl << endl << endl;

		switch (auswahl) {

		case 1:
			thm[zähler]->einschreiben_sg();                       // öffne hochschule, methode einschreiben_sg
			break;

		case 2:
			thm[zähler]->einschreiben_kurs();
			break;

		case 3:
			thm[zähler]->eintragen_note();
			break;

		case 4:
			for (int i = 0; i <= zähler; i++) {
				thm[i]->ausgabe();
			}

			break;

		case 5:
			zähler++;  // status auf 0 setzen, kurse auf 0 setzen , anzahl fächer wieder 0  zähler, kurs 1-3 auf 0 setzen
			break;
		}

	} while ((auswahl > 0) && (auswahl < 6));
	// cin.fail fehlerhafte eingabe

	cout << "Fehlerhafte Eingabe" << endl << endl;
	cout << "Programm beendet !!!" << endl << endl;
	system("pause");
	return 0;
}

HEADER:

#pragma once

#include <iostream>
#include <string>
#include <ctime>  // zeitverz. brauch ich nicht ?
#include <windows.h> // für zeiterzögerung

using namespace std;

class Hochschule
{ 
	string thm;

public:
	Hochschule(string);   // konstriktur
	string get_name();     // bruache ich das ??????????

	void einschreiben_sg();
	void einschreiben_kurs();	
	void eintragen_note();
	void ausgabe();
};

//--------------------------------------------------------------

class Fachbereich
{
	string bezeichnung;
	string aeb;  // 1
	string ti;   // 2
	int studiengang = 0;        // status ob bereits eingeschrieben oder nicht 0 nein, 1 aeb , 2 ti FÜR AUSGABE

public:
	Fachbereich();
	Fachbereich(string, string, string);  //konstruktor

	string get_bezeichnung();     // ausgabe WIllkommen in hochschule cpp
	int get_status();        // brauch ich für xterne abfrage, bevor man in kurs einschreibt, siehe hochschule, einschreiben_kurs

	void set_sg();    // student in     aeb oder ti einschreiben studiengang

	void set_aeb();  // methode zum einschreiben und namen speichern
	void set_ti();     // methode zum einschreiben und namen speichern

	void set_kurs();  // weiterleitung zu studiengang, da dort die kurse hinterlegt sind

	string get_sg();  // rückgabe stduiengang

};

//-----------------------------------------------------------------

class Studiengang
{
	string bezeichnung;
	int zähler = 0;                   //  man darf max. 2 kurse belegen zähler

	string mathe1;                   // namen
	string swt1;                      // namen
	string swt2;                       // namen

	int kurs1 = 0;    // status ob eingeschrieben
	int kurs2 = 0;
	int kurs3 = 0;

	//NOTEN

	int note_mathe1 = 0;        // note hinterlegt
	int note_swt1 = 0;
	int note_swt2 = 0;

public:
	Studiengang();
	Studiengang(string, string, string);
	void set_bezeichnung(string);
	string get_bezeichnung();

	void set_mathe1();  // status setzen, eintragen
	void set_swt1();
	void set_swt2();

	void set_note();  // note eintragen

	string get_kurs_note();

};

//----------------------------------------------------------------

class Student
{
	string name;
	int status = 0;  // wenn noch keine student ... wenn student dann 1

	                    //NEW STUDENT BEI EINCHRIEBEN
public:
	Student();
	Student(string);

	void set_status();
	int get_status();

	void set_name();
	string get_name();
};

CPP

#include "Header.h"

Hochschule::Hochschule(string x)                                                                // Konstr. wird in main() aufgerufen und THM erhält Namen
{
	thm = x;
}

string Hochschule::get_name() {                                                                                          // in main() Ausgabe Überschrift
	return thm;
}

void Hochschule::einschreiben_sg() {                                    // erstellt neuen FB, übergibt Konstr. FB,AEB,TI und öffnet das Einschreiben in SG

	Fachbereich *objekt;
	objekt = new Fachbereich("Informationstechnik - Elektrotechnik - Mechatronik", "Allgemeine Elektrotechnik Bachelor", "Technische Informatik");    

	cout << "Willkommen in: \t\t" << objekt->get_bezeichnung() << endl << endl << endl << endl;                         // holt FB-Bezeichnung und Ausgabe 

	objekt->set_sg();                                                                                           // öffnet das Einschreiben in Studiengang
}

void Hochschule::einschreiben_kurs() {

	Fachbereich objekt;     

	if (objekt.get_status() == 1) {                     // statusabfrage ob bereits in studiengang 1 ODER 2 eingeschrieben
		objekt.set_kurs();                                                                                                     // dann öffne einschreiben
	}

	else if (objekt.get_status() == 2) {
		objekt.set_kurs();
	}

	else {
		cout << "Bitte zuerst in einen Studiengang w\204hlen !!" << endl << endl;                               // ansonsten erst in studiengang einschreiben
	}
}

void Hochschule::eintragen_note() {    // naja, besser malal

	Studiengang objekt;

	objekt.set_note();

}

void Hochschule::ausgabe() {

	Fachbereich objekt1, objekt2;
	Student objekt3;
	Studiengang objekt4;

	cout << "\201bersicht aller Studenten, Studiengänge, Kurse und Noten;" << endl << endl << endl << endl;
	cout << "Fachbereich: " << objekt1.get_bezeichnung() << endl << endl;
	cout << "Student: " << objekt3.get_name() <<  endl << endl;
	cout << "Studiengang: " << objekt2.get_sg() << endl << endl;
	cout << "Kurse und Noten: " << objekt4.get_kurs_note() << endl << endl;

}

//--------------------------------------------------------------------------------------------
Fachbereich::Fachbereich(){ 
}

Fachbereich::Fachbereich(string x, string y, string z)  // konstruktor darf nicht 0 setzen, sonst bei jedem objekt erzeugen wieder = 0
{
	bezeichnung = x;
	aeb = y;
	ti = z;
}

string Fachbereich::get_bezeichnung() {                                                                             // für die Ausgabe "Willkomen in IEM"
	return bezeichnung;
}

int Fachbereich::get_status() {                                                    // für abfrage VOR kurs einschreiben, ob überhaupt schon in studiengang
	return studiengang;
}

void Fachbereich::set_kurs() {    // auswahl studiengang

	int auswahl;
	Studiengang objekt;

	if (studiengang == 1) {                                                                                             // wenn in AEB, dann swt1 mathe 1
		cout << "Sie befinden sich im Studiengang Allgemeine Elektrotechnik" << endl << endl;
		cout << "Sie k\224nnen sich nun in folgende Kurse w\204hlen: " << endl << endl;
		cout << "\t\t\t\t 1 = Mathe 1" << endl << endl;
		cout << "\t\t\t\t 2 = SWT 1" << endl << endl;
		cout << "Bitte w\204hlen Sie eine Nummer aus:" << endl << endl;
		cin >> auswahl;

		switch (auswahl) {

		case 1:
			objekt.set_mathe1();
			break;

		case 2:
			objekt.set_swt1();
			break;
		}
		cout << endl << endl << endl << endl << endl << endl << endl << endl << endl << endl << endl << endl << endl << endl << endl << endl << endl << endl << endl << endl << endl;
	}

	else if (studiengang == 2) {                                                                                // wenn in TI, dann swt1, swt2 und mathe 1
		cout << "Sie m\224chten sich in einen Kurs einschreiben." << endl << endl;
		cout << "Bitte w\204hlen Sie eine Nummer aus:" << endl << endl;
		cout << "\t\t\t\t 1 = Mathe 1" << endl << endl;
		cout << "\t\t\t\t 2 = SWT 1" << endl << endl;
		cout << "\t\t\t\t 3 = SWT 2" << endl << endl;
		cin >> auswahl;

		switch (auswahl) {

		case 1:
			objekt.set_mathe1();
			break;

		case 2:
			objekt.set_swt1();
			break;

		case 3:
			objekt.set_swt2();
			break;
		}
		cout << endl << endl << endl << endl << endl << endl << endl << endl << endl << endl << endl << endl << endl << endl << endl << endl << endl << endl << endl << endl << endl;
	}

	else {
		cout << " IRGENDWAS STIMMT MIT DER EINSCHREIBUNG IM STUDIENGANG NICHT, versuchen erneneutuueuuuuufufufufuf" << endl;
		system("pause");
	}
}

void Fachbereich::set_sg() {                                                                                               // in Studiengang einschreiben

	int auswahl = 0;

	if (studiengang == 0) {                                      // wenn studiengang = 0, ist noch kein studiengang gewählt und man kann sich einschreiben
		cout << "Sie m\224chten sich in einen Studiengang einschreiben." << endl << endl;
		cout << "Bitte w\204hlen Sie eine Nummer aus:" << endl << endl;
		cout << "\t\t\t\t 1 = AEB" << endl << endl;
		cout << "\t\t\t\t 2 = TI" << endl << endl;
		cin >> auswahl;
		cout << endl << endl << endl << endl << endl << endl << endl << endl << endl << endl << endl << endl << endl << endl << endl << endl << endl << endl << endl << endl << endl;

		switch (auswahl) {
		case 1:
			set_aeb();                                                                                                  // öffnet das dortige Einschreiben
			cout << " Sie haben sich erfolgreich in " << aeb << " eingeschrieben." << endl << endl;
			cout << studiengang;
			break;

		case 2:
			set_ti();                                                                                                   // öffnet das dortige Einschreiben
			cout << " Sie haben sich erfolgreich in " << ti << " eingeschrieben." << endl << endl;
			break;
		}

		// ausgabe EINGESCHRIEBEN !!!! mit verzögerung  ausgabe
	}

	else {
		cout << "Sie sind bereits in einen Studiengang eingeschrieben !!!" << endl << endl;      // falls studiengang = 1 oder 2, ist schon eingeschrieben
	}
}

void Fachbereich::set_aeb() {     // einschreiben in aeb öffnen konstruktor student und übergeben name udn setzen status 1 in stud und 1 in fachbere

	Student *neu;
	string eingabe;

	cout << "Sie m\224chten sich einschreiben in " << aeb << endl << endl;
	cout << "Geben Sie bitte Ihren Vor- und Nachnamen ein: " << endl << endl;
	cin >> eingabe;
	neu = new Student(eingabe);   // wenn status = 0 -> kein student,   1 -> student name schon gesetzt
	cout << endl << endl << endl << endl << endl << endl << endl << endl << endl << endl << endl << endl << endl << endl << endl << endl << endl << endl << endl << endl << endl;
	studiengang = 1;                         // aeb ist 1
	neu->set_status();
}

void Fachbereich::set_ti() {

	Student *neu;
	string eingabe;

	cout << "Sie m\224chten sich einschreiben in " << ti << endl << endl;
	cout << "Geben Sie bitte Ihren Vor- und Nachnamen ein: " << endl << endl;
	cin >> eingabe;
	neu = new Student(eingabe);
	cout << endl << endl << endl << endl << endl << endl << endl << endl << endl << endl << endl << endl << endl << endl << endl << endl << endl << endl << endl << endl << endl;
	studiengang = 2;
	neu->set_status();

}

string Fachbereich::get_sg() {  

	if (studiengang == 1) {
		return aeb;
	}

	else if (studiengang == 2) {
		return ti;
	}

	else {
		return "leer";                              // darf eigentlich nie vorkommen
	}
}

//--------------------------------------------------------------------------

Studiengang::Studiengang() {

}

Studiengang::Studiengang(string x, string y, string z)                     //Konstruktor mit übergabe status
{
	mathe1 = x;
	swt1 = y;
	swt2 = z;
}

string Studiengang::get_bezeichnung() {
	return bezeichnung;
}

void Studiengang::set_bezeichnung(string y) {

	bezeichnung = y;

	return;
}

void Studiengang::set_mathe1() {  // ich muss namen nicht überprüfen, da es vorher schon gemacht wird

	Student objekt;

	if (zähler < 2) {
		cout << "Willkommen " << objekt.get_name() << "in " << mathe1 << endl << endl;

		cout << "Sie werden nun eingeschrieben" << endl << endl;

		// zeitverzögerung
		kurs1 = 1;
		cout << "Sie belegen nun den Kurs " << mathe1 << "Viel Erfolg !" << endl << endl;

		zähler++;
	}

	else {
		cout << "Sie d\201rfen sich leider nur in 2 Kurse einschreiben" << endl << endl;
		system("pause");
	}
}

void Studiengang::set_swt1() {

	Student objekt;

	if (zähler < 2) {
		cout << "Willkommen " << objekt.get_name() << "in" << swt1 << endl << endl;

		cout << "Sie werden nun eingeschrieben" << endl << endl;

		// zeitverzögerung
		kurs2 = 1;
		cout << "Sie belegen nun den Kurs" << swt1 << "Viel Erfolg !" << endl << endl;

		zähler++;
	}

	else {
		cout << "Sie d\201rfen sich leider nur in 2 Kurse einschreiben" << endl << endl;
		system("pause");
	}
}

void Studiengang::set_swt2() {

	Student objekt;

	if (zähler < 2) {
		cout << "Willkommen " << objekt.get_name() << "in " << swt2 << endl << endl;

		cout << "Sie werden nun eingeschrieben" << endl << endl;

		// zeitverzögerung

		kurs3 = 1;
		cout << "Sie belegen nun den Kurs " << swt2 << "Viel Erfolg !" << endl << endl;

		zähler++;  // damit man max. 2 kurse belegen kann
	}

	else {
		cout << "Sie d\201rfen sich leider nur in 2 Kurse einschreiben" << endl << endl;
		system("pause");
	}
}

void Studiengang::set_note() {

	int note;
	int auswahl;
	int rückgabewert;

	Fachbereich objekt;
	rückgabewert = objekt.get_status();

	if (rückgabewert == 1) {                                         // wenn  AEB eingetragen 
		cout << "Sie m\224chten eine Note eintragen." << endl << endl;
		cout << "Bitte w\204hlen Sie den Kurs: " << endl << endl;
		cout << "\t\t\t\t 1 = Mathe 1" << endl << endl;
		cout << "\t\t\t\t 2 = Swt 1" << endl << endl;
		cin >> auswahl;

		switch (auswahl) {
			case 1:
				if(kurs1 == 1){                                   //wenn kurs1_status, dann mathe1 eintragen
					cout << "Welche Note soll eingetragen werden ?" << endl << endl;
					cin >> note;
					note_mathe1 = note;
				}

				else {
					cout << "Kurs wurde nicht belegt" << endl << endl;
					}

				break;

			case 2:
				if (kurs2 == 1) {                              //wenn kurs2_status, dann swt11 eintragen
					cout << "Welche Note soll eingetragen werden ?" << endl << endl;
					cin >> note;
					note_swt1 = note;
				}

				else {
				cout << "Kurs wurde nicht belegt" << endl << endl;
				}

				break;
		}

	}

	else if (rückgabewert == 2) {                                 //TI eingeschrieben ??
		cout << "Sie m\224chten eine Note eintragen." << endl << endl;
		cout << "Bitte w\204hlen Sie den Kurs: " << endl << endl;
		cout << "\t\t\t\t 1 = Mathe 1" << endl << endl;
		cout << "\t\t\t\t 2 = Swt 1" << endl << endl;
		cout << "\t\t\t\t 3 = Swt 2" << endl << endl;
		cin >> auswahl;

		switch (auswahl) {
			case 1:
				if (kurs1 == 1) {                          //wenn kurs1_status, dann mathe1 eintragen
					cout << "Welche Note soll eingetragen werden ?" << endl << endl;
					cin >> note;
					note_mathe1 = note;
				}

				else {
					cout << "Kurs wurde nicht belegt" << endl << endl;
				}

			break;

		case 2:
			if (kurs2 == 1) {    //wenn kurs2_status, dann swt1 eintragen
				cout << "Welche Note soll eingetragen werden ?" << endl << endl;
				cin >> note;
				note_swt1 = note;
			}

			else {
				cout << "Kurs wurde nicht belegt" << endl << endl;
			}

			break;

		case 3:
			if (kurs3 == 1) {    //wenn kurs3_status, dann swt2 eintragen
				cout << "Welche Note soll eingetragen werden ?" << endl << endl;
				cin >> note;
				note_swt2 = note;
			}

			else {
				cout << "Kurs wurde nicht belegt" << endl << endl;
			}

			break;
		}
	}

	else {
		cout << "Sie sind weder in einem Studiengang, noch in einem Kurs eingeschrieben" << endl << endl;
	}
}

string Studiengang::get_kurs_note() {
	if (kurs1 == 1) {                   // Mathe 1 mit Note
		cout << mathe1;
			if (note_mathe1 != 0) {
				cout << note_mathe1;
			}
			else {
				cout << "keine Note";
			}
	}

	if (kurs2 == 1) {                   // Swt1  mit Note
		cout << swt1;
		if (note_swt1 != 0) {
			cout << note_swt1;
		}
		else {
			cout << "keine Note";
		}
	}

	if (kurs3 == 1) {                   // Swt2 mit Note
		cout << swt2;
		if (note_swt2 != 0) {
			cout << note_swt2;
		}
		else {
			cout << "keine Note";
		}
	}

	else {
		return "keine Kurse und keine Noten";
	}
}

//--------------------------------------------------------------------------
Student::Student() {

}

Student::Student(string x) {
	name = x;
}

string Student::get_name() {     // bei der Ausgabe benötigt
	if (status == 1) {
		return name;
	}

	else {
		return "leer";
	}
}

void Student::set_name() {
	return;
}

void Student::set_status() {   // status auf eins, damit andere wissen, name steht schon
	status = 1;
}

int Student::get_status() {
	return status;
}

Schlangenmensch

Naja, du erzeugst in fast allen Funktionen neue Objekte irgendeiner Klasse. Diese Objekte werden nach den Funktionen jeweils zerstört. Wenn du die nicht zu Beispiel in Member Variablen speicherst, kannst du auf die nicht aus anderen Funktionen drauf zugreifen.

Ausführlicheres Feedback kann ich grade nicht geben, da ich nur am Smartphone sitze und das lesen und schreiben so etwas mühselig ist.

wob

Das einzig sinnvolle scheint mir der Kommentar ganz am Anfang deines Programms zu sein:

/*Erstelle folgende Klassen: 
  
Hochschule (Container für deine Fachbereiche, Methoden zum Hinzufügen und Entfernen von Fachbereichen) 
Fachbereich (Container für Studiengänge, Methoden zum Hinzufügen und Entfernen von Studiengängen) 
Studiengang (der spezifische Studiengang, Methoden zum Einschreiben ...) 
Student 
*/

Der Kommentar (vermutlich die Aufgabe?) liest sich sinnvoll: eine Hochschule hat Fachbereiche. Fachbereiche haben Studiengänge. In Studiengänge können sich Studenten einschreiben.

Du hast etwas anderes gebaut: du erzeugst erst eine Hochschule (Variable objekt , übrigens ein äußerst schlechter Name. Objekt kann alles sein. Vergib vernünftige Namen. Wenn es keine bestimmte Hochschule sein soll, ist ggf. der Name der Klasse in Kleinbuchstaben sinnvoll, also Hochschule hochschule; )

Danach kommt dein thm-Array von 10 uninitialisierten Hochschulpointern. Was soll das? Ich schrieb schon: verwende std::vector für sowas! Mir ist auch nicht klar, warum jeder Student auf eine eigene (andere) Hochschule gehen sollte. Warum kann man in die Hochschule eine Note eintragen? Das ergibt doch so keinen Sinn!

Konkret meine ich das hier:

Hochschule *objekt;
    objekt = new Hochschule ("Technische Hochschule Mittelhessen");           // neue Hochschule erbaut
 
    Hochschule *thm[10];                                                                        // konstruktor NULL übergeben an beide werte und nur einer

D.h. du erzeugst die "Technische Hochschule Mittelhessen" im Freispeicher und speicherst einen Pointer auf diese Hochschule in "objekt". So weit, so gut. Aber warum willst du dann 10 Zeiger auf Hochschule haben und warum nennst du dieses Array "thm"? Die THM ist doch bereits in "objekt" referenziert! Außerdem wird hier kein Konstruktor gerufen. Der Kommentar ergibt also keinen Sinn.

Dann der Fachbereich: soll das nun ein Fachbereich sein oder 3 Fachbereiche? Lass es beim Einfachsten: die Klasse Fachbereich soll nur einen (nicht mehrere) FB modellieren!

Ebenso dein Studiengang. Die Klasse sollte genau einen SG modellieren, nicht mathe, swt und sonstwas!

Der Status in der Klasse Student scheint mir auch nicht sinnvoll zu sein.

Generelle Tipps:
[]Pack die Eingabe von Tastatur nicht in die Methoden deiner Klassen. Eine Hochschule modelliert eine Hochschule, nicht das Einlesen von zu Hochschule zugehörigen Daten. Das erleichtert dir auch später das Testen deines Codes.
[]Deine Kommentare wie "öffne hochschule" sind merkwürdig. Da wird doch gar nichts geöffnet!
[*]Vermeide Umlaute in Namen von Variablen!

Zur Lösung der Aufgabe, scheint mir, reicht es nicht aus, hier im Forum irgendwas zu lesen. Du solltest vorlesungsbegleitendes Material lesen, dir ggf. ein gutes Buch besorgen (wie z.B. "Der C++-Programmierer" von Breymann oder "C++ Primer" von Lippman) und mit deinen Kommilitionen sprechen. Es scheint hier so viel grundlegendes zu fehlen, dass wir hier nicht mal schnell helfen können.

Smuji

habe nun den c++ programmierer, bin schon am durcharbeiten und habe das alte projekt schon gelöscht..... verstehe schon einige fehler, welche ich gemacht hatte....

danke

Smuji

also, ich bin zurück. ich habe mir auch mal eine lösung von einem kumpel angeschaut, bei dem es funktioniert.

ich habe nun erstmal versucht nur das einschreiben zu realisieren und habe es ähnlich gemacht wie er (er hat VS2012, ich nutze 2017)

bei ihm klappt es, bei mir sind 85 fehler ?!?
ich versuche nun die fehler zu elimineren, kann sie aber nicht deuten.

Beispiel, bezogen auf:

class Hochschule
{
	int studenten_zaehler;              // zählt die aktuell eingeschriebenen Studenten
	Student *liste[10];                // 10 Studenten können in die THM
	Fachbereich fachbereich;            // einen Fachbereich in die Hochschule integrieren (ein Objekt der Klasse Fachbereich)

public:
	Hochschule();

	void add_student(string);
};

Erhalte ich die Fehler:

- Fehler C2143 Syntaxfehler: Es fehlt ";" vor "*" 16
- Fehler C4430 Fehlender Typspezifizierer - int wird angenommen.
- Fehler C2238 Unerwartete(s) Token vor ";" 16 letzteAufgabe

Mich wundert, dass es bei ihm funktioniert, obwohl er es ähnlich hat.
Weiß jemand Rat ?

**
Header**

#pragma once

#include <iostream>
#include <string>
#include <iomanip>
#include <limits>

using namespace std;

enum { TI = 0, AE };  // TI =0  AE =1  dadurch muss ich kein element 0 oder 1 verwenden, sondern sehe direkt 

class Hochschule
{
	int studenten_zaehler;              // zählt die aktuell eingeschriebenen Studenten
	Student *liste[10];                // 10 Studenten können in die THM
	Fachbereich fachbereich;            // einen Fachbereich in die Hochschule integrieren (ein Objekt der Klasse Fachbereich)

public:
	Hochschule();

	void add_student(string);
};

//---------------------------------------------------------------------------------------------------------

class Fachbereich
{
	string fb_name;

public:
	Fachbereich();

	string get_fb_name();
	Studiengang *studiengang[2];
};

//----------------------------------------------------------------------------------------------------------

class Studiengang
{

	string sg_name;                 // aeb oder TI
	string pv_name[2];        // 2 PVs pro Studiengang möglich              
	int anzahl_studenten;             // hier wird die anzahl gespeichert

public:
	Studiengang(string);
	int get_anzahl();                   // gibt die anzahl_stuenten zurück
	string get_sg_name();
	string get_pv_name(int);
	void student_hinzugefügt();
};

//---------------------------------------------------------------------------------------------------

class Student
{
	string name;
	string fachbereich;
	string studiengang;
	string kurs[2];
	int note[2];

public:
	Student(string);
	void set_fachbereich(string);
	void set_studiengang(string);
	void set_pv(string, string);
	void set_pv_note(string, int);

	string get_name();
	string get_fb();
	string get_sg();
	string get_pv(int);
	int get_pv_noten(string);
};

CPP

#include "Header.h"

Hochschule::Hochschule() : studenten_zaehler{ 0 } {                       // Konstruktor setzt studenten_anzahl zähler auf 0
	for (int i = 0; i < 10; i++) {
		liste[i] = NULL;                                      // alle Elemente = NULL setzen, da  ? sonst zufällige/unbekannte Werte vorhanden ?
	}
	cout << "Willkommen in der Technischen Hochschule Mittelhessen" << endl << endl;    // Ausgabe WILLKOMMEN
}

void Hochschule::add_student(string name) {
	string eingabe;
	int note;

	if (studenten_zaehler == 10) {      // wenn der zähler bei 10 steht, können keine studenten mehr rein
		cout << "Alle Studienplätze sind schon belegt";
		return;                                                              // rausspringen aus der methode
	}

	cout << "Bitte wählen Sie einen der folgenden Studiengänge." << endl << endl;
	cout << "AE = Allgemeine Elektrotechnik" << endl << endl;
	cout << "TI = Technische Informatik" << endl << endl;
	cout << "Bitte geben Sie die Kurzbezeichnung des gewünschten Studiengangs ein: " << endl << endl;
	cin >> eingabe;

			if (cin.fail()) {                                                        // bei fehlerhafter Eingabe
				cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
				cout << "Fehlerhafte Eingabe" << endl << endl;
			}

	if (eingabe == "TI") {                                                    // wenn TI ausgewählt wurde

			if (fachbereich.studiengang[TI]->get_anzahl() == 5) {                    // 0 = ti wenn getanzahl an ti die 5 gibt dann sind 5 ti,ler drinnen
				cout << "Kein weiterer Student möglich" << endl << endl;
				return;                                               // raus aus der methode
			}

		liste[studenten_zaehler] = new Student(name);  // bsp. studenten_zähler[0] = new student(eingegeber name) übergeben. konstr. student schreibt namen
		liste[studenten_zaehler]->set_fachbereich(fachbereich.get_fb_name()); // liste[0] öffnet set_fachbereich und übergibt den geholten IEM namen
		liste[studenten_zaehler]->set_studiengang(fachbereich.studiengang[TI]->get_sg_name()); //über fachbereich in HS, objekt von FB, greife ich auf objekt Studiengang zu und öffne die methode 

		liste[studenten_zaehler]->set_pv(fachbereich.studiengang[TI]->get_pv_name(0), fachbereich.studiengang[TI]->get_pv_name(1));
		// öffne set_pv (name) und übergebe per indirektem zugriff über rückggabewert den namen , je nachdem ob 0 oder 1 als attribut übergeben

		cout << " Tragen Sie bitte Ihre Noten für die jeweilige Veranstaltung ein." << endl << endl;
		cout << fachbereich.studiengang[TI]->get_pv_name(0) << ": ";  // 

		do {
			cin >> note;
			cout << endl << endl;

				if ((cin.fail()) || (note < 1) || (note > 5)) {
				cerr << "Fehlerhafte Eingabe. Bitte versuchen Sie es noch einmal." << endl << endl;
				cin.clear();
				cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
				note = 0;
				}
			} while ((note < 0) || (note > 5));

			liste[studenten_zaehler]->set_pv_note(liste[studenten_zaehler]->get_pv(0), note);    // übergebe kurs 0 = name und note 0 = note

			cout << fachbereich.studiengang[TI]->get_pv_name(1) << ": ";  // 

		do {
				cin >> note;
				cout << endl << endl;

				if ((cin.fail()) || (note < 1) || (note > 5)) {
					cerr << "Fehlerhafte Eingabe. Bitte versuchen Sie es noch einmal." << endl << endl;
					cin.clear();
					cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
					note = 0;
				}
			} while ((note < 0) || (note > 5));

			liste[studenten_zaehler]->set_pv_note(liste[studenten_zaehler]->get_pv(1), note);    // übergebe kurs 0 = name und note 0 = note

			fachbereich.studiengang[TI]->student_hinzugefügt();     // anzahl_studenten in studiengang erhöht
			studenten_zaehler++;   // auch in hochschule ein weiterer student
			return;    // raus aus der methode
	}

// NUN DAS GLEICHE MIT AE--------------------------------------------------------------------------------------------------------------------------

	else if (eingabe == "AE") {                         //  wenn AE ausgewählt wurde

				if (fachbereich.studiengang[AE]->get_anzahl() == 5) {                    // 0 = ti wenn getanzahl an ti die 5 gibt dann sind 5 ti,ler drinnen
					cout << "Kein weiterer Student möglich" << endl << endl;
					return;                                               // raus aus der methode
					}

		liste[studenten_zaehler] = new Student(name);  // bsp. studenten_zähler[0] = new student(eingegeber name) übergeben. konstr. student schreibt namen
		liste[studenten_zaehler]->set_fachbereich(fachbereich.get_fb_name()); // liste[0] öffnet set_fachbereich und übergibt den geholten IEM namen
		liste[studenten_zaehler]->set_studiengang(fachbereich.studiengang[AE]->get_sg_name()); //über fachbereich in HS, objekt von FB, greife ich auf objekt Studiengang zu und öffne die methode 

		liste[studenten_zaehler]->set_pv(fachbereich.studiengang[AE]->get_pv_name(0), fachbereich.studiengang[AE]->get_pv_name(1));
		// öffne set_pv (name) und übergebe per indirektem zugriff über rückggabewert den namen , je nachdem ob 0 oder 1 als attribut übergeben

		cout << " Tragen Sie bitte Ihre Noten für die jeweilige Veranstaltung ein." << endl << endl;
		cout << fachbereich.studiengang[AE]->get_pv_name(0) << ": ";  // 

			do {
				cin >> note;
				cout << endl << endl;

					if ((cin.fail()) || (note < 1) || (note > 5)) {
						cerr << "Fehlerhafte Eingabe. Bitte versuchen Sie es noch einmal." << endl << endl;
						cin.clear();
						cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
						note = 0;
					}
				} while ((note < 0) || (note > 5));

						liste[studenten_zaehler]->set_pv_note(liste[studenten_zaehler]->get_pv(0), note);    // übergebe kurs 0 = name und note 0 = note

						cout << fachbereich.studiengang[AE]->get_pv_name(1) << ": ";  // 

			do { 
						cin >> note;
						cout << endl << endl;

						if ((cin.fail()) || (note < 1) || (note > 5)) {
							cerr << "Fehlerhafte Eingabe. Bitte versuchen Sie es noch einmal." << endl << endl;
							cin.clear();
							cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
							note = 0;
						}
			   } while ((note < 0) || (note > 5));

						liste[studenten_zaehler]->set_pv_note(liste[studenten_zaehler]->get_pv(1), note);    // übergebe kurs 0 = name und note 0 = note

						fachbereich.studiengang[AE]->student_hinzugefügt();     // anzahl_studenten in studiengang erhöht
						studenten_zaehler++;                                 // auch in hochschule ein weiterer student
						return;                                             // raus aus der methode
					}

	else {
						cout << "Unbekannter Studiengang" << endl << endl;
						return;
						}
	}

//-------------------------------------------------------------------------------------------------------------------------------------------------

Fachbereich::Fachbereich(){
	fb_name = "IEM";
	studiengang[TI] = new Studiengang("Technische Informatik");        // 0 ist TI
	studiengang[AE] = new Studiengang("Allgemeine Elektrotechnik");       // 1 ist AE

	cout << "Der Fachbereich" << fb_name << " wurde erstellt";
}

string Fachbereich::get_fb_name() {
	return fb_name;
}

//--------------------------------------------------------------------------------------------------------------------------------------------------------

Studiengang::Studiengang(string name){               // konstruktor setzt PV namen
	sg_name = name;
	anzahl_studenten = 0;

	if (sg_name == "Technische Informatik") {   // wenn studiengang[TI] aufruft name zurück und = TI , dann ...

		pv_name[0] = "Softwaretechnik 2";
		pv_name[1] = "Mathematik 1";
	}

	else {
		pv_name[0] = "Softwaretechnik 1";   // wenn AE, dann ..
		pv_name[1] = "Mathematik 1";
	}

	cout << "Ein Studiengang mit dem Namen ( " << name << " ) wurde erstellt." << endl;
}

int Studiengang::get_anzahl() {
	return anzahl_studenten;
}

string Studiengang::get_sg_name() {
	return sg_name;
}

string Studiengang::get_pv_name(int x) {
	return pv_name[x];
}

void Studiengang::student_hinzugefügt() {
	anzahl_studenten ++ ;
}

//-----------------------------------------------------------------------------------------------------------

Student::Student(string neuer_name){            // erhält namen beim erstellen eines neuen students
	name = neuer_name;                          // name wird lokal in name gespeichert
	cout << "Ein neuer Student wurde angelegt." << endl << endl;
}

void Student::set_fachbereich(string name) {
	fachbereich = name;
}

void Student::set_studiengang(string name) {
	studiengang = name;
}

void Student::set_pv(string name1, string name2) {
	kurs[0] = name1;
	kurs[1] = name2;
}

void Student::set_pv_note(string pv_name, int note_pv) { /// ????????????????????????ß
	kurs[0] = pv_name;
	note[0] = note_pv;    // musterlösung hat ein  wenn note größer als 5 oder kleiner als 1

	if (pv_name == kurs[0]) {
		note[0] = note_pv;
	}

	else {
		note[1] = note_pv;
	}
}

int Student::get_pv_noten(string name_pv) {

	if (kurs[0] == name_pv) {
		return note[0];
	}

	else if (kurs[1] == name_pv) {
		return note[1];
	}

	else{
		cout << " Keine Noten hinterlegt " << endl << endl;
		return 0;
	}
}

string Student::get_name() {
	return name;
}

string Student::get_fb() {
	return fachbereich;
}

string Student::get_sg() {
	return studiengang;
}

string Student::get_pv(int x) {
	return kurs[x];
}

daddy_felix

Smuji schrieb:

- Fehler C2143 Syntaxfehler: Es fehlt ";" vor "*" 16
- Fehler C4430 Fehlender Typspezifizierer - int wird angenommen.
- Fehler C2238 Unerwartete(s) Token vor ";" 16 letzteAufgabe

Mich wundert, dass es bei ihm funktioniert, obwohl er es ähnlich hat.
Weiß jemand Rat ?

Da hast du wohl bei Copy&Paste einen Fehler gemacht oder am Code rumgewurschtelt. Die Fehlermeldungen oben beziehen sich darauf, dass der Compiler zu diesem Zeitpunkt die Klasse "Student" nicht kennt.

Dafür gibt es zwei Lösungsvarianten:

(unschön) du verschiebst die Deklaration der Klasse "Student" nach oben
(sauber) Du erstellt eine Forward-Deklaration:

// includes

class Student; // Dem COmpiler mitteilen, dass es irgendwo eine Klasse "Student" gibt

class Hochschule 
{
//...
Student* liste[10];
};

class Student
{
// ...
};

edit: den Rest habe ich mir nicht sonderlich gut angesehen. Was mir aber spontan aufgefallen ist: Da gibt es diverse "new", aber kein einziges "delete".

Smuji

danke.

sind die "delete" zwingend notwendig ? habe sie extra erstmal weggelassen

Variante 1 (unschön) habe ich ausprobiert und es sind aus 85 Fehler nun nur noch 30 geworden.

Trotzdem erhalte ich noch die Meldung:

Fehler C2079 "Hochschule::fachbereich" verwendet undefiniertes class "Fachbereich"

bezogen auf:

class Hochschule
{
	int studenten_zaehler;              // zählt die aktuell eingeschriebenen Studenten
	Student *liste[10];                // 10 Studenten können in die THM
	Fachbereich fachbereich;            // einen Fachbereich in die Hochschule integrieren (ein Objekt der Klasse Fachbereich)

wob

Wenn du die deletes weglässt, hast du ein Speicherleck. Wird dir bei 10 Studenten nicht auffallen. Aber warum willst du dir eigentlich gleich so unsaubere Dinge angewöhnen? Verwende KEIN new! Dann brauchst du auch kein delete bzw. kannst es nicht vergessen.

Nutze std::vector anstelle deiner Arrays + Indexvariablen.
Nutze std::make_unique anstatt von new , wenn du Objekte auf dem Freispeicher erstellen willst.

Lies dir insbesondere mal im Buch das Kapitel über std::vector durch.

daddy_felix

Smuji schrieb:

sind die "delete" zwingend notwendig ? habe sie extra erstmal weggelassen

Nun, du könntest auch einfach Smart Pointer verwenden.

Aber so wie du das hast: JA die sind notwendig! (zugegeben, du wirst in diesem Mini-Programm keine negative Auswirkungen feststellen, aber so einen Mist sollte man sich gar nicht erst angewöhnen)

Smuji

also wenn ich das buch richtig interpretiere, mache ich aus:

Student *liste[10];

ein

vector<Student> liste[10];

es wird gesagt, dies sei nicht so fehleranfällig, aber was genau ist der unterschied ?

ich arbeite doch später auch noch mit liste[1] , obwohl ich vector nutze ?!?

weiter hinten im Programm mache ich ja folgendes:

liste[i] = NULL;

dies ist nun fehlerhaft, da:

Kein '=' Operator stimmt mit diesem Operanden überein.
Operandentypen sind: std::vector<Student, std::allocator<Student>> = int

liegt das daran, dass man bei vector kein = NULL mehr machen muss ?

achso, ich habe oben noch was editiert, als ihr schon die antwort geschrieben habt...

wob

Nein, das siehst du falsch.

Du sollst aus:

int studenten_zaehler;              // zählt die aktuell eingeschriebenen Studenten 
    Student *liste[10];                // 10 Studenten können in die THM

einfach nur folgendes machen:

std::vector<Student> studenten;

Ganz einfach.

Wenn du vector<Student> liste[10]; schreibst, dann hast du ja 10 Vectoren!