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

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

  • S

    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;
}
    0
  • S

    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.

    0
  • W

    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.

    0
  • S

    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

    0
  • S

    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];
}
    0
  • D

    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:

    1. (unschön) du verschiebst die Deklaration der Klasse "Student" nach oben
    2. (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".

    0
  • S

    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)
    0
  • W

    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.

    0
  • D

    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)

    0
  • S

    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...

    0
  • W

    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!

    0
  • S

    ok, danke, ich probiere es erstmal auf der alten art und weise zum laufen zu bekommen und dann arbeite ich mich durt unique_ptr und vector, denn so ganz ist das noch nicht in meinem verständnis....

    ich füge nun erstmal die deletes ein, allerdings besteht dann noch immer das problem,

    das Variante 1 (unschön) ausprobiert habe 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)
    0
  • S

    Smuji schrieb:

    ok, danke, ich probiere es erstmal auf der alten art und weise zum laufen zu bekommen und dann arbeite ich mich durt unique_ptr und vector, denn so ganz ist das noch nicht in meinem verständnis....

    Dann versteh das. Nicht auf die alte Weise lernen / machen. Du hast doch jetzt ein schönes Buch in dem das erklärt ist. Außerdem scheinst du "die alte Art und Weise" auch noch nicht verstanden zu haben.

    Ein Vektor kannst du dir grob als Array vorstellen, welches automatisch mit wächst wenn du Daten hinzufügst.

    Wenn du also ein

    std::vector<student> studenten;

    hast, dann kannst du mit

    student xyz;
sutdenten.push_back(xyz);

    da ein Student hinzufügen.

    Delete brauchst du dann nicht mehr (einer der Vorteile). Wenn der Vektor irgendwann nicht mehr existiert, sorgt der dafür, dass der Speicher wieder richtig freigegeben wird.

    Deine Fehlermeldung hat den selben Grund wie die letzte. Fachbereich ist an der Stelle noch nicht bekannt. Lösbar zum Beispiel durch eine Forward Deklaration .

    0
  • S

    das problem ist, ist dass der dozent schon 60+ ist under überhaupt nicht mit uniqe_ptr und vector etc. arbeitet, sondern noch nach dem alten standard....

    wenn er irgendwelche aufgaben oder abfragen stellt, immier mit delete und arrays.....

    vllt. will er auch nur, dass wir noch den alten standard lernen.

    ähnlich wie man in der fahrschule auf einen schalter lernt, auch wenn man vor hat sich 'nen automatik zu kaufen.

    ich habe mein problem gelöst und das programm läuft.

    ich habe alle klassen und cpps in einzelne "dateien" aufgeteilt, alle header, using namespace etc. in einer einzigen Header.h zusammengefügt und diese überall bekannt gemacht.

    🙂

    0
  • ?

    Smuji schrieb:

    das problem ist, ist dass der dozent schon 60+ ist under überhaupt nicht mit uniqe_ptr und vector etc. arbeitet, sondern noch nach dem alten standard....=)

    Es gab nie einen alten Standard ohne vector. Das Zeug wurde mit C++ geboren. Aber es gibt die alten Dozenten die einem C + Klassen als C++ verkaufen.

    0
  • Mod

    Das war noch nie aktuell. Das Vermeiden von expliziten new/deletes und der daraus resultierenden Probleme war sogar die Hauptinitiative hinter der Erfindung von C++ und ist tief in der Sprache verwurzelt. Es ist das grundlegende Prinzip dahinter, wie man in C++ mit Ressourcen umgeht und seine Datenstrukturen plant. unique_ptr & Co. sind bloß Neuerungen, die ein bisschen angenehmer machen, was man früher nötigenfalls selber programmiert hätte. Aber der Punkt ist: Egal wie lange es her ist, man hat es stets so gemacht, wenn man C++ gemacht hat. Wenn nicht, dann hat man C mit cout gemacht.

    0
  • W

    Genau!

    Und ich verwende praktisch in allen meinen Programmen (die mehr tun als "Hallo Welt" auszugeben) std::vector. Wenn man C++ lernt, sind std::vector und std::string wohl die ersten Klassen, die man kennen sollte. Wenn euer Prof. die nicht nutzt, sollte der Kurs sich auch nicht "C++"-irgendwas nennen. Und wie out schon sagte, std::vector gab es selbstverständlich auch schon in C++98.

    Der unique_ptr wurde erst mit C++11 standardisiert. Inzwischen ist 2018. In den letzten 7 Jahren ist die Zeit gerade im Bereich der Programmierung ja auch stehen geblieben... ähm... naja. Ansonsten google mal den Begriff "RAII".

    Also lerne lieber nach dem Buch als nach eurem Kurs.

    0
  • ?

    wob schrieb:

    Also lerne lieber nach dem Buch als nach eurem Kurs.

    Das Problem ist ja, dass der Dozent seinen eigenen Misst in der Klausur abfragt, also was bleibt dir übrig. 2x C++ parallel lernen macht man wohl nicht... man hat ja auch noch andere Klausuren. Also den Misst lernen und spätestens nach der Prüfung wieder alles vergessen, und dann wieder von vorne anfangen. 😃

    0
  • D

    Smuji schrieb:

    Trotzdem erhalte ich noch die Meldung:

    Fehler C2079 "Hochschule::fachbereich" verwendet undefiniertes class

    Sorry, aber muss man dir jeden einzelnen Bissen vorkauen? An dieser Stelle kannst du mal versuchen, dein gerade eben neu erworbenes Wissen praktisch anzuwenden.

    0
Anmelden zum Antworten