// C++ Trainer, 17.5.2011, all rights reserved

/*
Leichtathletik
 Basisklasse: Startnummer, Vorname, Name, Herkunftsland


3 Sportdisziplinen
  sprung (weitsprung, hochsprung, dreisprung, ..?), wurf (hammerwerfen, speerweitwurf),
  lauf (z.B. 800m, 200m, 100m-Lauf, hürdenlauf, staffel, marathon)
  (mit halbfinale, finale...?)
  -> vererbung, 3 abgeleitete klassen

  Hauptklasse LA:
  #vorname
  #name
  #startnummer
  #land

  Klasse Sprung:
  #sprungdisziplin
  #wert[3]

  Klasse Teilnehmer12:
  Methode:


  Unterklassen: Weitsprung, Dreisprung
  Weitsprung:


  Klasse Teilnehmer8:
  Unterklassen: Hochsprung, Stabhochsprung


*/
#include <iostream>
using namespace std;


/* ################## KLASSEN ################## */

class LA
{
  protected: string vorname;
             string name;
             unsigned short int startnummer;
             string land;


  public: void set_vorname();
          void set_name();
          void set_startnummer();
          void set_land();

          string get_vorname();
          string get_name();
          unsigned short int get_startnummer();
          string get_land();
  LA();
  ~LA();
};

class sprung : public LA
{
  protected: string sprungdisziplin;
             double wert[3];

  public: void set_sprungdisziplin();
          void set_wert();

          string get_sprungdisziplin();
          double get_wert();

  sprung();
  ~sprung();
};

class teilnehmer12 : public sprung
{
  protected: //datentyp name;

  public:


 teilnehmer12();
 ~teilnehmer12();
};

class teilnehmer8 : public sprung
{
  protected:

  public:

 teilnehmer8();
 ~teilnehmer8();
};

class weitsprung : public teilnehmer12
{
  private: string bezeichnung;

 weitsprung();
 ~weitsprung();
};

class dreisprung : public teilnehmer12
{
  private: string bezeichnung;

 dreisprung();
 ~dreisprung();
};

class hochsprung : public teilnehmer8
{
 private: string bezeichnung;

 hochsprung();
 ~hochsprung();
};

class stabhochsprung : public teilnehmer8
{
 private: string bezeichnung;

 stabhochsprung();
 ~stabhochsprung();
};

/* ################## METHODEN ################## */


/* ### METHODEN LA ### */
void LA::set_vorname()
  {
   cout<<" Bitte den Vornamen eingeben: ";
   cin>>vorname;
  }

    void LA::set_name()
  {
    cout<<" Bitte den Namen eingeben: ";
   cin>>name;
  }

    void LA::set_startnummer()
  {
   cout<<" Bitte die Startnummer eingeben: ";
   cin>>startnummer;
  }

    void LA::set_land()
  {
    cout<<" Bitte das Land eingeben: ";
   cin>>land;
  }

  string LA::get_vorname()
  {
       return vorname;
  }

     string LA::get_name()
  {
       return name;
  }

    unsigned short int LA::get_startnummer()
    {
     return startnummer;
    }

    string LA::get_land()
  {
       return land;
  }


    LA::LA()
  {
   vorname= " ";
   name= " ";
   startnummer = 0;
   land=" ";
  }

  LA::~LA()
{


}
/* ### METHODEN sprung ### */

void sprung:: set_wert()
{
for( int i=0 ;i<3  ;i++  )
{
cin>>wert[i];
}
}

void sprung:: sortieren()
{

}
sprung:: sprung()
  {
  }
  sprung:: ~sprung()
  {
  }

/* ### METHODEN teilnehmer12 ### */

teilnehmer12::teilnehmer12()
{

}

teilnehmer12::~teilnehmer12()
{

}

/* ### METHODEN teilnehmer8 ### */

teilnehmer8::teilnehmer8()
{

}
teilnehmer8::~teilnehmer8()
{
}

/* ### METHODEN weitsprung ### */

weitsprung::weitsprung()
{
}

weitsprung::~weitsprung()
{
}
/* ### METHODEN dreisprung ### */

dreisprung::dreisprung()
{
}

dreisprung::~dreisprung()
{
}
/* ### METHODEN hochsprung ### */

hochsprung::hochsprung()
{
}

hochsprung::~hochsprung()
{
}
/* ### METHODEN stabhochsprung ### */

stabhochsprung::stabhochsprung()
{
}

stabhochsprung::~stabhochsprung()
{
}

int main()
{

  char disziplin;
  int i=0;

  cout<<"Für welche Disziplin möchten Sie Teilnehmer angeben?\n";
  cout<<"a) Weitsprung\n";
  cout<<"b) Dreisprung\n";
  cout<<"c) Hochsprung\n";
  cout<<"d) Stabhochsprung\n";
  cin>>disziplin;

  cout<<"Wieviele Teilnehmer starten in dieser Disziplin?\n";
  cin>>teilnehmer_zahl;

  switch (disziplin)
  {
    case 'a':
    case 'A':
    {
      weitsprung *teilnehmer_weitsprung[12];  //Deklaration Zeigerarray
                                              //beliebige Zahl zur Begrenzung... kann später noch geändert werden
      for(i=0;i<teilnehmer_zahl;i++)
      {
           teilnehmer_weitsprung[i]= new weitsprung;  // Objekte der Klasse weitsprung dynamisch erzeugen
     //         teilnehmer_weitsprung[i]->methode();
       //       teilnehmer_weitsprung[i]->methode();
      }
    }
      break;
    case 'b':
    case 'B':
        {
      dreisprung *teilnehmer_dreisprung[12];  //Deklaration Zeigerarray
                                              //beliebige Zahl zur Begrenzung... kann später noch geändert werden
      for(i=0;i<teilnehmer_zahl;i++)
      {
           teilnehmer_dreisprung[i]= new dreisprung;  // Objekte der Klasse weitsprung dynamisch erzeugen
     //         teilnehmer_dreisprung[i]->methode();
       //       teilnehmer_dreisprung[i]->methode();

      }
    }
      break;
    case 'c':
    case 'C':
        {
      hochsprung *teilnehmer_hochsprung[8];  //Deklaration Zeigerarray
                                              //beliebige Zahl zur Begrenzung... kann später noch geändert werden
      for(i=0;i<teilnehmer_zahl;i++)
      {
           teilnehmer_hochsprung[i]= new hochsprung;  // Objekte der Klasse weitsprung dynamisch erzeugen
     //         teilnehmer_hochsprung[i]->methode();
       //       teilnehmer_hochsprung[i]->methode();

      }
    }
      break;
    case 'd':
    case 'D':
        {
      stabhochsprung *teilnehmer_stabhochsprung[8];  //Deklaration Zeigerarray
                                              //beliebige Zahl zur Begrenzung... kann später noch geändert werden
      for(i=0;i<teilnehmer_zahl;i++)
      {
           teilnehmer_stabhochsprung[i]= new stabhochsprung;  // Objekte der Klasse weitsprung dynamisch erzeugen
    //          teilnehmer_stabhochsprung[i]->methode();
    //          teilnehmer_stabhochsprung[i]->methode();

      }
    }
      break;
    default: ;
  }

  getchar();
  return 0;
}