ich kriege langsam graue Haare...
Ich soll mit C++ ein Programm schreiben, dass Kursteilnehmer und einen Kurs erzeugt. Die Kursteilnehmer sollen dem Kurs per Array hinzugefügt werden.
Ich habe eine Klasse Kursteilnehmer erzeugt, die auch wunderbar funktioniert.

Nur irgendwo habe ich noch einen riesigen Denkfehler, was die Kurs-Klasse angeht. Eigentlich wollte ich nun ein Array erzeugen, dass Kursteilnehmer enthält und dieses will ich an das Kurs-Objekt anfügen.

Aber ich kann mich vor Fehlermeldungen momentan kaum noch retten und weiß langsam nicht mehr weiter. Ich glaube, ich mache irgendwo noch etwas Prinzipielles falsch:

//Forward-Deklaration der Klasse TEILNEHMER
//class TEILNEHMER;
//Das klappt so aber nicht
#include "TEILNEHMER.h"

class KURS
{
      private:
              /*Variablen für Kursname, maximale Teilnehmerzahl,
               *Mindestteilnehmeranzahl, Teilnehmerobjekt, Teilnehmerarray,
               *Anzahl aktueller Teilnehmer im Kurs und Anzahl erzeugter Kurse
               */              
              std::string name;              
              short int maxPart;
              short int minPart;
              TEILNEHMER* tn;
              TEILNEHMER* teilnehmer[];              
              short int partCounter;
              static int courseCounter;      

      public:             
             KURS(std::string a);
             ~KURS();
             void setName(std::string name);
             static int getCount();
             std::string getName();
             void addParticipant(tn);
             void createParticipant();

};

  //Konstruktor fuer Kurse
  KURS::KURS(std::string a):name(a), maxPart(10), minPart(3), partCounter(0),
                         teilnehmer[10]
  {   
   courseCounter++;                                
  }

//...

  //Fragt beim Anwender die Teilnehmerdaten fuer den Teilnehmer ab, der
  //hinzugefuegt werden soll
  void KURS::createParticipant()
  {
       //Es wird nur ein neuer TN hinzugefuegt, wenn weniger als 10
       //TN im Kurs sind
       if(partCounter < maxPart)
       {    
            std::string name;
            int ima;

            std::cout << "Bitte den vollstaendigen Namen des Teilnehmers "
                      "angeben: ";
            std::cin >> name;
            std::cout << std::endl << std::endl;
            std::cout << "Bitte die Matrikelnummer des Teilnehmers angeben: ";
            std::cin >> ima;    
            KURS::addParticipant(tn(name, ima));            

       }

  }

  //Fuegt einen Kursteilnehmer hinzu
  void KURS::addParticipant(tn)
  {       
          partCounter++;
          teilnehmer[partCounter - 1] = tn;
          std::cout << "Teilnehmer erfolgreich hinzugefuegt!" << std::endl;       
  }

Und das sind die Fehlermeldungen:

26  variable or field `addParticipant' declared void 
26  expected `;' before '(' token 
  In constructor `KURS::KURS(std::string)': 
34  expected `(' before '[' token 
34  expected `{' before '[' token 
34  At global scope: 
34  expected unqualified-id before '[' token 
34  expected `,' or `;' before '[' token 
66  variable or field `addParticipant' declared void 
66  `int KURS::addParticipant' is not a static member of `class KURS' 
15  invalid use of non-static data member `KURS::tn' 
66  from this location 
67  expected `,' or `;' before '{' token 
  In member function `void KURS::createParticipant()': 
90  `addParticipant' is not a member of `KURS' 
90  `((KURS*)this)->KURS::tn' cannot be used as a function

Vielen Dank für eure Hilfe!

Liebe Grüße,
Oli

void addParticipant(const TEILNEHMENR *tn);

Ich hoffe, du kennst schon die Klasse std::vector<T>, denn das würde einiges bei dir vereinfachen.
Du wirst nämlich sehen, daß selbst mit obiger Änderung dein Code nicht funktioniert, weil du einerseits Zeiger verwendest, andererseits aber direkt ein Objekt der Methode übergibst.

P.S: Klassennamen sollten nicht ganz groß geschrieben werden, sondern (wenn überhaupt) nur der erste Buchstabe (Kurs, Teilnehmer, ...)

Ich hoffe, du kennst schon die Klasse std::vector<T>, denn das würde einiges bei dir vereinfachen.

Nein, leider noch nicht. Mit Java war das alles immer so einfach und hier ... *seufz*. Ich mach' mich mal schlau, was die Klasse angeht und melde mich nochmal, sollte ich weitere Fragen haben!

P.S: Klassennamen sollten nicht ganz groß geschrieben werden, sondern (wenn überhaupt) nur der erste Buchstabe (Kurs, Teilnehmer, ...)

Ist in unserem (nicht immer korrekten) Uni-Skript so gemacht. Ich gewöhn' es mir gleich mal wieder ab!

Edit: Was wäre denn richtiger? Sollte ich Objekte oder Zeiger an Methoden übergeben?

//Forward-Deklaration der Klasse TEILNEHMER
//class TEILNEHMER;
#include "TEILNEHMER.h"

class KURS
{
      private:
              /*Variablen für Kursname, maximale Teilnehmerzahl,
               *Mindestteilnehmeranzahl, Teilnehmerobjekt, Teilnehmerarray,
               *Anzahl aktueller Teilnehmer im Kurs und Anzahl erzeugter Kurse
               */              
              std::string name;              
              short int maxPart;
              short int minPart;
              TEILNEHMER* participant;
              short int partCounter;
              static int courseCounter;      

      public:             
             KURS(std::string a);
             ~KURS();
             void setName(std::string name);
             static int getCount();
             std::string getName();
             void addParticipant(TEILNEHMER* participant);
             void createParticipant();

};

  //Konstruktor fuer Kurse, noch unvollständig
  KURS::KURS(std::string a):name(a), maxPart(10), minPart(3), partCounter(0)

  {   
   courseCounter++;                                
  }

  //...

  //Fuegt einen Kursteilnehmer hinzu
  void KURS::addParticipant(TEILNEHMER* participant)
  {       
          partCounter++;
          //teilnehmer[partCounter - 1] = participant;
          std::cout << "Teilnehmer erfolgreich hinzugefuegt!" << std::endl;       
  }

  //Fragt beim Anwender die Teilnehmerdaten fuer den Teilnehmer ab, der
  //hinzugefuegt werden soll
  void KURS::createParticipant()
  {
       //Es wird nur ein neuer TN hinzugefuegt, wenn weniger als 10
       //TN im Kurs sind
       if(partCounter < maxPart)
       {    
            std::string name;
            int ima;

            std::cout << "Bitte den vollstaendigen Namen des Teilnehmers "
                      "angeben: ";
            std::cin >> name;
            std::cout << std::endl << std::endl;
            std::cout << "Bitte die Matrikelnummer des Teilnehmers angeben: ";
            std::cin >> ima;
            TEILNEHMER participant(name, ima);    
            KURS::addParticipant(participant*);            

       } else {              
              std::cout << "Teilnehmer konnte nicht hinzugefuegt werden!" <<
                        std::endl;              
              std::cout << "Der Kurs ist voll belegt. Bitte versuchen sie es zu" 
                   "einem anderen Zeitpunkt noch einmal!" << std::endl;
       }

  }

Die Fehlermeldungen sind nun übersichtlicher:

In member function `void KURS::createParticipant()': 

90 expected primary-expression before ')' token

Wo ist der Fehler?

Desweiteren: Wenn ich die kritische Stelle auskommentiere, dann kompiliert er. ABER: In der Zeile, wo ein neuer Kursteilnehmer erzeugt werden soll, ruft das Programm den Destruktor von TEILNEHMER und nicht den Konstruktor auf. Es wird einfach kein Teilnehmer erzeugt. Boah, ich raste gleich aus...

Im Zweifelsfall bitte auch folgende Hinweise beachten:
C/C++ Forum :: FAQ - Sonstiges :: Wohin mit meiner Frage?

Dieses Posting wurde automatisch erzeugt.

Wo ist der Fehler?

da:

KURS::addParticipant(participant*);

du willst:

addParticipant(&participant);