Kurse
{
private:
	int fach;     // 18 Faecher durch Nummern (0-17) dargestellt
	bool ist_lk;  // lk = Leistungskurs
public:
        Kurse();
	static int kurse_cnt;
	void Set_fach(int, bool);
};
int Kurse::kurse_cnt=0;

Die Methode:

void Kurse::Set_fach(int fach_nummer, bool leistungskurs)
{
Kurse::kurse_cnt++;
fach = fach_nummer;
ist_lk = leistungskurs;
}

und möchte nun erstmal leere Kurse erstellen. Da nicht bekannt ist, wieviele Kurse es geben wird, brauche ich ein dynamisches Objekt der Klasse Kurse.?

Kurse *kurse = new Kurse;

Ich glaube, dass ich jetzt einen Vektor "kurse" dynamischer Länge hab, stimmt das? Ich erstelle also zu Testzwecken erstmal 10 Kurse:

kurse[Kurse::kurse_cnt].Set_fach(0, true);
kurse[Kurse::kurse_cnt].Set_fach(1, true);   // 1 wäre in dem Fall Deutsch
kurse[Kurse::kurse_cnt].Set_fach(2, true);   // 2 = Englisch
kurse[Kurse::kurse_cnt].Set_fach(5, true);   // 5 = Mathe
kurse[Kurse::kurse_cnt].Set_fach(6, true);   // alles Leistungskurse, daher true
kurse[Kurse::kurse_cnt].Set_fach(7, true);   // beim Aufrug von Set_fach ->
kurse[Kurse::kurse_cnt].Set_fach(8, true);   // kurse_cnt +1
kurse[Kurse::kurse_cnt].Set_fach(9, true);
kurse[Kurse::kurse_cnt].Set_fach(10, true);
kurse[Kurse::kurse_cnt].Set_fach(11, true);

Ich finde es selbst absolut hässlich und kann mir nicht vorstellen, dass man das so löst, aber das ist das einzige, was ich zum Laufen bekommen habe. Jedoch sagt mir der Debugger bei über 8-maligem Aufruf von Set_fach, dass der Heap Allocator Overflow irgendwas und unterbricht mehrmals. Ohne Debugger läufts aber "wunderbar". Wer wäre so nett, mich aufzuklären und mir zu zeigen, wie man hier ein dynamisches Objekt richtig erzeugt?
Vielen Dank schonmal für jedwede Hilfe.
Gruß, Julian

Ich nutze "Microsoft Visual C++ 2010 Express" unter Win7

class Kurs {
    // Methoden und Variablen der Klasse Kurs.
    // ...
};

Und der benutzende Code:

//Vector dynamischer Länge:
std::vector<Kurs> kurse;
//Neuen Kurs erstellen (mit Konstruktor)
kurse.push_back(Kurs(1) ); //1 entspricht Deutsch
kurse.push_back(Kurs(2) ); //2 entspricht English
//Auf den ersten Kurs zugreifen und das Fach ändern
kurse[0].Set_fach(5); //5 entspricht Mathe
// ...

Weitere Funktionen von std::vector findest du unter: http://www.cplusplus.com/reference/stl/vector/

pyhax

Eine Ausnahme (erste Chance) bei 0x7770dcbb in planer.exe: 0xC0000374: Ein Heap wurde beschädigt.
Unbehandelte Ausnahme bei 0x7770dcbb in planer.exe: 0xC0000374: Ein Heap wurde beschädigt.

Leider ohne Zeilenangabe o.ä. Was bedeutet das "Ein Heap wurde beschädigt"?

Gruß, Julian

Kurse *kurse = new Kurse;

hast du einmal Speicher angefordert, wo einmla Kurse reinpasst. Möchtest mehrere Kurse, z.B. müsst das tun

Kurse *kurse = new Kurse [10];

// allgemeiner
Kurse *kurse = new Kurse [irgende anzahl];

Jetzt hast du Platz für 10 Kurse.
Dynamisch ist das in dem Sinne das zur Laufzeit entscheiden kannst wie groß dein Kurse Array ist. Einmal allociert allerdings ist die Größe fest, und erweitert sich nicht automatisch, falls du dich danach entscheidest mehr Kurse zu speichern

freigeben tust du den Speicher mit

delete [] kurse

die Anzahl brauchst du hier nich angeben.

So nachdem man ihm das erklärt hat, kann man jetz sagen.

Schau dir mal lieber std::vector an !

MfG

Eventuell unabhängig davon, aber im Zuge der Arbeiten mit std::vector sagt mir der Debugger:

Eine Ausnahme (erste Chance) bei 0x7770dcbb in planer.exe: 0xC0000374: Ein Heap wurde beschädigt.
Unbehandelte Ausnahme bei 0x7770dcbb in planer.exe: 0xC0000374: Ein Heap wurde beschädigt.

Leider ohne Zeilenangabe o.ä. Was bedeutet das "Ein Heap wurde beschädigt"?

Du hast wahrscheinlich irgendwelche Speicherstellen modifiziert, die Dir gar nicht gehörten, und damit scheinbar Datenstrukturen zerstört, die für die Verwaltung des Freispeichers verwendet wird. Demjenigen, der den Speicher verwaltet ist dies aufgefallen und hat dafür gesorgt, dass das Programm terminiert wird. Du hast quasi noch Glück gehabt, dass Dein Computer nicht explodiert ist!

Tipp1: Verwende Datenstrukturen aus der Standardbibliothek, sofern möglich.
Tipp2: Verwende den Debug-Modus dieser Bibliothek, um Fehler früher erkennen zu können (siehe dazu in der Dokumnetation Deines Compilers nach).

C und C++ ist nunmal kein "Baby-Spielzeug". Es ist spitz und man kann sich damit das Auge ausstechen, wenn man nicht weiß, was man da tut.

Du hast quasi noch Glück gehabt, dass Dein Computer nicht explodiert ist!

Vorsicht mit solchen Scherzen, nachher glaubt das noch jemand.

Neben der Klasse "Kurse" habe ich noch 2 weitere Klassen "Schueler" und "Lehrer". Da ich jetzt weiß, dass ich dynamische Objekte dann verwende, wenn die Größe selbigen Objekts erst zur Laufzeit feststeht, erzeuge ich also zur Laufzeit so viele "Schueler" und "Lehrer", wie Eintraege im jeweiligen Verzeichnis sind:

Schueler *schueler = new Schueler[EintraegeCnt("datenbank\\schueler\\*.sch")];
Lehrer *lehrer = new Lehrer[EintraegeCnt("datenbank\\lehrer\\*.leh")];

Mutet auch etwas improvisiert an, funktioniert aber.
Jetzt gilt es für mich, einen Algorithmus zu finden, der nach und nach alle Schueler abarbeitet und in Kurse "steckt" und danach den Kursen Lehrer zuordnet.
Die Anzahl der Kurse ist vorerst unbekannt, ABER:
ich kann ähnlich wie mit den Schülern und Lehrern eine Funktion schreiben, die kurz checkt, wieviele Schüler welches Fach gewählt haben und als return-Wert die sich daraus ergebende Anzahl an Kursen zurückgeben um damit ebenfalls ein dynamisches Objekt der Art

Kurse *kurse = new Kurse[ZaehleKurse(schueler)];  // alle schueler übergeben

zu erzeugen.
Hab's auch probiert:

int ZaehleKurse(Schueler[]);  // Prototyp
int ZaehleKurse(Schueler schueler[])
{   // <-- Hier zeigt der Debugger hin und meckert
    int cnt=0, kursNr, kurse[19];  
    // [...] die Anzahl der Kurse wird ermittelt   
    return cnt; 
}

wenn ich zu Testzwecken die Funktion erstmal so aufrufe, bekomme ich als Return-Wert auch tatsächlich die korrekte Anzahl an Kursen, jedoch eben mit Unterbrechung durch den Debugger. Es kommt kein Fehler, keine "Heap-Beschädigung" - nur eine "Aufrufliste", wo er auf die obige Zeile zeigt und mir aus der "crtexec.c" die Stelle zeigt:

__initenv = envp;
mainret = main(argc, argv, envp);

Mache ich irgendwas falsch? Darf man dynamische Objekte nicht einfach so als Parameter übergeben?
Oder würdet ihr mir, auch wenn ich berechnen kann, wieviele Kurse/Lehrer/Schüler es zur Laufzeit gibt, trotzdem zu vectoren raten?

Danke für die hilfreichen Tips nochmal , Julian

std::vector<Schueller> schueller(EintraegeCnt("datenbank\\schueler\\*.sch") );

Dadurch macht der Vektor eigentlich genau das selbe was du machst, mit dem Unterschied das er einfacher zu handhaben ist und sich auch noch nachträglich vergrößern kann.

class Schueler						
{
public:
	Schueler();							
	static int schueler_cnt;
};
int Schueler::schueler_cnt=0;

Schueler::Schueler()
{				
	id = schueler_cnt;							
	Schueler::schueler_cnt++;
}

mit "Schueler::schueler_cnt"
Der ganze Code ist natürlich etwas länger, aber bevor ich meinen ganzen code rechtfertigen muss, habe ich nur die wesentlichen Teile kopiert. Die Sachen funktionieren im Grunde ja auch und für 2 Jahre Grundkurs Informatik (ein bisschen rumscripten mit python) können die Prüfer von mir bei weitem nicht das erwarten, was ein erfahrener Programmierer schreiben würde.

Ich würde aber gerne wissen, warum es "schöner" ist, std::vector<> zu verwenden. Welche Vorteile haben sie gegenüber meinem dynamischen Objekt in meinem konkreten Fall (bevor ich jetzt einfach wieder ins kalte Wasser springe)?

Das Problem vom Debugger bleibt...
Gruß

Ich würde aber gerne wissen, warum es "schöner" ist, std::vector<> zu verwenden. Welche Vorteile haben sie gegenüber meinem dynamischen Objekt in meinem konkreten Fall

Das Prinzip von RAII ist eigentlich, dass du keine Speicheranforderungen außerhalb von Klassen hast. Das bedeutet, dass die unterste "Instanz" immer auf dem Stack liegt, und das wiederrum bedeutet, dass deren Destruktor am Ende des Gültigkeitsbereichs sicher aufgerufen wird. Kurzum: Der vector garantiert dir ein sicheres delete[]. Zudem Methoden wie .resize() und .push_back().

Zu der statischen Schüleranzahl: Schlechte Idee. Abgesehen davon, dass du im Destruktor die Schüleranzahl wieder verringern solltest, sind statische Variablen an sich nicht so schön. Warum sollte ein Schüler von den anderen wissen? Nein. Wenn du Pointer verwenden würdest, würdest du so vorgehen:

void foo(Schueler* schueler, unsigned anzahl); // oder std::size_t statt unsigned

Mit Arrays so:

template<unsigned N>
void foo(Schueler (&)schueler[N]); // Zugegeben, das ist etwas fortgeschrittener

Aber optimalerweise nutzt du einfach einen Vektor:

void foo(std::vector<Schueler>& schueler); // schueler.size() verrät die Größe

LINK : fatal error LNK1104: Datei "C:\Users\Shizzophate\Documents\Visual Studio 2010\Projects\planer\Debug\planer.exe" kann nicht geöffnet werden.
========== Erstellen: 0 erfolgreich, Fehler bei 1, 0 aktuell, 0 übersprungen ==========

Wieso denn jetzt der Linker?

Vielen Dank für die Hilfe nochmal an euch!