Meine Idee: Es sollen 5(Mathe,Deutsch....) verschiedene Kurse geben und 10 Teilnehmer(Max,Tim,Kai...)geben.
Jeder Teilnehmer soll wissen in welchem Kurs er ist( also sozusagen den string name jedes Teilnehmers).
Die Kurse sollen nicht wissen wer ihre Teilnehmer sind.

Ich habe mich wirklich den ganzen Tag bemüht komme aber nun nicht weiter:
Ich weiß nicht wie ich nun 10 Teilnehmer Objekte erstelle, sie den Kursen zuordenen kann und dardurch die Informationen bekommen kann, in welchem Kurs derjenige ist und wann sein Kurs endet.

Ich denke mal das meine Klasse Kurs und die Funktionsdefinitionen richtig sind,
bei der Klasse Teilnehmer und der Funktionsdefinitionen bin ich mir sehr unsicher und es fehlt einiges.

Ich bitte um Hilfe

Kurse.h

#include <string>
using namespace std;

class Kurse
{
private:
	string Bezeichnung;
	float Beginn;
	float Ende;
	string Tag;
public:
	Kurse();
	~Kurse();

	string get_Bezeichnung();
	float get_Beginn();
	float get_Ende();
	string get_Tag();

	void set_Bezeichnung(string name);
	void set_Beginn(float zeit);
	void set_Ende(float zeit);
	void set_Tag(string day);

};

Teilnehmer.h

#include "Kurse.h"
#include <string>
using namespace std;

class Teilnehmer
{
private: 
	string Name;
	Kurse *kurs[4];
public:
	Teilnehmer();
	~Teilnehmer();
	void set_Name(string name);
	string get_Name();

	void set_Kurs(Kurse *kurs);
	Kurse *get_Kurs();
};

Kurse.cpp

#include <string>
using namespace std;

class Kurse
{
private:
	string Bezeichnung;
	float Beginn;
	float Ende;
	string Tag;
public:
	Kurse();
	~Kurse();

	string get_Bezeichnung();
	float get_Beginn();
	float get_Ende();
	string get_Tag();

	void set_Bezeichnung(string name);
	void set_Beginn(float zeit);
	void set_Ende(float zeit);
	void set_Tag(string day);

};

Teilnehmer.cpp

#include "Teilnehmer.h"
#include <iostream>
using namespace std;

Teilnehmer::Teilnehmer()
{
}
Teilnehmer::~Teilnehmer()
{
}
void Teilnehmer::set_Name(string name)
{
	Name=name;
}
string Teilnehmer::get_Name()
{
	return Name;
}

main.cpp

#include <iostream>
#include <string>
#include "Kurse.h"
#include "Teilnehmer.h"
using namespace std;
int main()
{
	string bezeichnung;
	float zeit;

	Kurse Kursarray[5];
	for(int x=0;x<=4;x++)
	{
		cout<<"Geben sie für den "<<x+1<<" Kurs einen Namen ein: ";
		cin>>bezeichnung;
		Kursarray[x].set_Bezeichnung(bezeichnung);
		cout<<endl;

	}
	for (int x=0;x<=4;x++)
	{
		cout<<"Geben sie für den Kurs: "<<Kursarray[x].get_Bezeichnung()<<" die Startzeit ein: ";
		cin>>zeit;
		Kursarray[x].set_Beginn(zeit);
	}
	for (int x=0;x<=4;x++)
	{
		cout<<"Geben sie für den Kurs: "<<Kursarray[x].get_Bezeichnung()<<" die Schlusszeit ein: ";
		cin>>zeit;
		Kursarray[x].set_Ende(zeit);
	}

}

hier auch der source code als vc++ projekt

Ich habe mich wirklich den ganzen Tag bemüht komme aber nun nicht weiter:
Ich weiß nicht wie ich nun 10 Teilnehmer Objekte erstelle, sie den Kursen zuordenen kann und dardurch die Informationen bekommen kann, in welchem Kurs derjenige ist und wann sein Kurs endet.

Ich würde den Teilnehmer anders designen:

class Teilnehmer
{
private:
    string Name;
    std::vector<Kurse*> kurs;  // Wozu auf 4 festlegen? Außerdem ist vector komfortabler
public:
    Teilnehmer(std::string Name);  // Gibt es Teilnehmer ohne Namen? Wohl nein, also ab in den Konstruktor damit
    // ~Teilnehmer();  Wozu brauchst du einen Destruktor?
    // void set_Name(string name); Kann ein Teilnehmer seinen Namen ändern? Wohl kaum, also raus damit
    string get_Name();

    void set_Kurs(Kurse *kurs);
    // Kurse *get_Kurs(); Was soll hier zurückgegeben werden? Vermutlich doch alle Kurse, also:
    vector<Kurse*> get_Kurs();
};

Und das implementierst du dann. Es wäre mir noch ein Streitthema, ob kurs nun Zeiger oder konkrete Objekte enthalten soll. Der Fall mit den Zeigern trifft meiner Meinung nach wohl eher die Realität, kommt aber auf dein konkretes Modell an, was du genau möchtest.

Noch ein paar Bemerkungen:
- Objektorientiertes Design ist dir wohl neu? Mach nicht alles nach was du siehst, ohne es zu verstehen (hier: Konstruktor, Destruktor, Getter, Setter).

- Deine Namen sind schrecklich. Warum heißt die Klasse Kurse, obwohl es nur einen Kurs modelliert? Dafür hat Teilnehmer ein Member namens kurs, welches mehrere Kurse enthält. Total verwirrend.

Mit den obigen Tipps würde ich auch noch einmal die Klasse Kurse überarbeiten (den Namen lasse ich jetzt einmal unverändert, obwohl schlecht gewählt), zum Beispiel so:

class Kurse
{
private:
    string Bezeichnung;
//    float Beginn;   Float für Zeit?
//    float Ende;
//    string Tag;     Und ein Tag ist eine Zeichenkette?
//                    Wie wäre es damit:
    Datumstyp Beginn;
    Datumstyp Ende; // Datumstyp ist eine noch zu modellierende Klasse
                    // Alternatives Modell: Beginn und Dauer
public:
    Kurse(std::string Bezeichnung, Datumstyp Beginn, Datumstyp Ende); // Siehe oben
    // ~Kurse();  Siehe oben

    string get_Bezeichnung();
    Datumstyp get_Beginn();
    Datumstyp get_Ende();

    void set_Bezeichnung(string name);  // Weiß jetzt nicht ob das Sinn macht die Bezeichnung ändern zu können, kommt auf dein genaues Modell an
    void set_Beginn(Datumstyp zeit);    // Man sollte Kurse aber zetilich verschieben können
    void set_Ende(Datumstyp zeit);      // Wobei hierbei das Modell Beginn+Dauer von Vorteil wäre
};

P.S.: Und niemals using namespace in Headern benutzen!

Eine neue Frage:
wenn ich get_Methoden baue, ist es dann gut sie inline zu schreiben oder ist das ein schlechter Programmierstil?

Wenn deine Konstruktoren/Destruktioren nichts tun, brauchst du die nicht selber schreiben.

Wenn du STL Container nutzt, spaarst du dir ne Menge Verwaltung.

#include <string>
#include <vector>
#include <iostream>

class Kurs
{
public:
    Kurs(std::string n, std::string t, float v, float b) : name(n), tag(t), von(v), bis(b)
    { if (bis < von) std::swap(von,bis); }

    std::string Name() { return name;}

private:
    std::string name;
    std::string tag;
    float von;
    float bis;
};

class Student
{
public:
    Student(std::string n) : name(n) {};

    bool signIn(Kurs &k)
    {
        std::vector<Kurs*>::iterator it;
        it = kurse.begin();
        while(it != kurse.end())
        {
            if (*it == &k)
            {
                return false;
                std::cout << name << " ist schon in " << k.Name() << std::endl;
             }
            ++it;
        }

        std::cout << name << " meldet sich an für " << k.Name() << std::endl;
        kurse.push_back(&k);
        return true;
    }

    bool signOut(Kurs &k)
    {
        std::vector<Kurs*>::iterator it;
        it = kurse.begin();
        while(it != kurse.end())
        {
            if (*it == &k)
            {
                std::cout << name << " meldet sich ab von " << k.Name() << std::endl;
                kurse.erase(it);
                return true;
            }
            ++it;
        }

        std::cout << name << " ist garnicht in " << k.Name() << std::endl;
        return false;
    }

private:
    std::string name;
    std::vector<Kurs*> kurse;
};

int main()
{
    Kurs bio("Bio","MoMiFr",9,12);
    Kurs mathe("Mathe","MoMiFr",5,9);
    Kurs cpp("C++","tgl.",12,16);

    Student fleissig("nichIch");
    Student faul("auchNichIch");

    fleissig.signIn(bio);
    fleissig.signIn(bio);
    fleissig.signIn(mathe);
    fleissig.signIn(mathe);
    fleissig.signIn(cpp);
    fleissig.signIn(cpp);

    faul.signIn(bio);
    faul.signIn(mathe);
    faul.signIn(cpp);

    faul.signOut(bio);
    faul.signOut(mathe);
    faul.signOut(cpp);
}

Eine neue Frage: wenn ich get_Methoden baue, ist es dann gut sie inline zu schreiben oder ist das ein schlechter Programmierstil?

Ich halte das mit den Inlines so: Ich denke das macht der Compiler sinniger als ich Was die Methodenbennenung angeht gibts im Forum immer wieder Threads in denen alle Heiß ihre Version verteidigen meiner Meinung nach ists nur wichtig konsistent zu bleiben.

Ich machs so:

class A {
public:
    A() : mMemberName(-4) {}
    void memberName(int s) { mMemberName = s;} // setter
    int memberName() { return mMemberName; }   // getter

    int memberNAME(int *s=0) { if (!s) return mMemberName; mMemberName = *s; return mMemberName;} // mach ich nie, gibts aber einige
private:
 int mMemberName;
};

int main()
{
    A hallohi;
    std::cout << hallohi.memberName() << std::endl; // -4
    hallohi.memberName(8);

    int karl = 20;
    std::cout << hallohi.memberNAME() << std::endl; // 8
    std::cout << hallohi.memberNAME(&karl) << std::endl; // 20
}

Anfaenger111 schrieb:

Eine neue Frage: wenn ich get_Methoden baue, ist es dann gut sie inline zu schreiben oder ist das ein schlechter Programmierstil?

Ich halte das mit den Inlines so: Ich denke das macht der Compiler sinniger als ich Was die Methodenbennenung angeht gibts im Forum immer wieder Threads in denen alle Heiß ihre Version verteidigen meiner Meinung nach ists nur wichtig konsistent zu bleiben.

Ja, aber es schadet nicht, dem Compiler etwas auf die Sprünge zu helfen. Und gerade bei häufig benutzten Gettern hilft Inlining sehr viel. Damit meine ich nicht, die Methoden in einer cpp-Datei inline zu definieren. Stattdessen sollte man sie gleich in der Klassendeklaration definieren (was gleichbedeutend mit inline ist). Denn Funktionen die in anderen Übersetzungseinheiten definiert sind können nur die cleversten Compiler/Linker inlinen, daher ist es gut die Funktionsdefinition im Header zu haben. Und da ein Getter meistens nur ein einzelner Ausdruck ist, wird die Klassendeklaration dadurch auch nicht unübersichtlich. Wenn es deutlich mehr als eine Zeile Code für den Getter ist, sollte er vermutlich ohnehin nicht inline sein.
Das gilt natürlich gleichermaßen für alle anderen Funktionseinzeiler.