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

[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:

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

[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!

[Smuji]

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)

[Schlangenmensch]

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 .

[Smuji]

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.

[Ein ehemaliger Benutzer]

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.

[SeppJ]

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.

[wob]

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.

[Ein ehemaliger Benutzer]

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.

[daddy_felix]

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.