/*

  Author: Shen Zeng

  Datum: 09.05.2010

                    */





 #include <string>

 #include <cstdio>

 #include <math.h>

 #include <iostream>



using namespace std;



class geomKoerper {

      protected:

             std::string oberflaefarbe;

             double volumen;

             double oberflaeinhalt;



             // unterscheiden, um später Gesamtfläche des Turms algorithmisiert berechnen zu können

             double mantelflaeinhalt;

             double o_flaeinhalt;

             double u_flaeinhalt;



      public:

             double getOberflaeinhalt(){return oberflaeinhalt;};

             double getVolumen(){return volumen;};

             double getMantelflaeinhalt(){return mantelflaeinhalt;};

             double getO_flaeinhalt(){return o_flaeinhalt;};

             double getU_flaeinhalt(){return u_flaeinhalt;};

             std::string getFarbe(){return oberflaefarbe;};

};





//-----------------------------------------------------------------------------------------------------------------------





class Pyramide : public geomKoerper {

      private:

              double a, b, h;

      public:

             // Konstruktor

             Pyramide(std::string xf, double xa, double xb, double xh) {

                    oberflaefarbe = xf;

                    a = xa;

                    b = xb;

                    h = xh;



                    // Fakten aus der Geometrie

                    volumen = 1/3*a*b*h;

                    oberflaeinhalt = sqrt ( (1/2*a)*(1/2*a) + h*h)  * b + sqrt ( (1/2*b)*(1/2*b) + h*h)  * a;

                    mantelflaeinhalt = sqrt ( (1/2*a)*(1/2*a) + h*h)  * b + sqrt ( (1/2*b)*(1/2*b) + h*h)  * a + a*b;

                    o_flaeinhalt = 0;

                    u_flaeinhalt = a*b;

              }

};





//-----------------------------------------------------------------------------------------------------------------------





class Kugel : public geomKoerper {

      private:

              double r;

      public:

             Kugel(std::string xf, double xr) {

                    oberflaefarbe = xf;

                    r = xr;



                    volumen = 4*r*r*r*(3.14159)/3;

                    oberflaeinhalt = 4*(3.14159)*r*r;

                    mantelflaeinhalt = oberflaeinhalt;

                    o_flaeinhalt = 0;

                    u_flaeinhalt = 0;

             }

};





//-----------------------------------------------------------------------------------------------------------------------





class Zylinder : public geomKoerper {

    private:

        double r, h;

    public:

        Zylinder(std::string xf, double xr, double xh) {

               oberflaefarbe = xf;

               r = xr;

               h = xh;



               volumen = (3.14159)*r*r*h;

               oberflaeinhalt = 2*(3.14159)*r * (2+h);

               mantelflaeinhalt = h*2*(3.14159)*r;

               o_flaeinhalt = (3.14159)*r*r;

               u_flaeinhalt = (3.14159)*r*r;

         }

};





//-----------------------------------------------------------------------------------------------------------------------





class Kegel : public geomKoerper {

      private:

              double r, h;

      public:

             Kegel(std::string xf, double xr, double xh) {

                      oberflaefarbe = xf;

                      r = xr;

                      h = xh;



                      volumen = 1/3*r*r*(3.14159)*h;

                      oberflaeinhalt = (3.14159)*r*r + (3.14159)*r* sqrt(r*r + h*h);

                      mantelflaeinhalt = (3.14159)*r* sqrt(r*r + h*h);

                      o_flaeinhalt = 0;

                      u_flaeinhalt = (3.14159)*r*r;

             }

};





//-----------------------------------------------------------------------------------------------------------------------





class Kegelstumpf : public geomKoerper {

      private:

              double r1, r2, h;

      public:

             Kegelstumpf(std::string xf, double xr1, double xr2, double xh) {

                      oberflaefarbe = xf;

                      r1 = xr1;

                      r2 = xr2;

                      h = xh;



                      volumen = h*(3.14159)/3 * (r2*r2 + r2*r1 + r1*r1);

                      oberflaeinhalt = (3.14159)*(r1*r1+r2*r2) + (r2+r1)*(3.14159)* sqrt ((r2-r1)*(r2-r1) + h*h);

                      mantelflaeinhalt = (r2+r1)*(3.14159)* sqrt ((r2-r1)*(r2-r1) + h*h);

                      o_flaeinhalt = (3.14159)*r1*r1;

                      u_flaeinhalt = (3.14159)*r2*r2;

              }

};





//-----------------------------------------------------------------------------------------------------------------------





class Quader : public geomKoerper {

      private:

              double a, b, h;

      public:

             Quader(std::string xf, double xa, double xb, double xh) {

                      oberflaefarbe = xf;

                      a = xa;

                      b = xb;

                      h = xh;



                      volumen = a*b*h;

                      oberflaeinhalt = 2*(a*b + b*h + a*h);

                      mantelflaeinhalt = 2*(b*h + a*h);

                      o_flaeinhalt = a*b;

                      u_flaeinhalt = a*b;

             }

};





//-----------------------------------------------------------------------------------------------------------------------





class List {

      // einzelt verkettete Listenstruktur speichtert Zeiger auf geomKoerper



      private:

              geomKoerper* figur;

              List* next;

              List* anker;



      public:

              List();



              void add (geomKoerper*); // "addToFront"

              void loesch (geomKoerper* k);



              List* findK (geomKoerper*);

              List* findvorK (geomKoerper*); // findet Vorgänger von k und gibt Zeiger auf diesen zurück

              void tauschK (geomKoerper*, geomKoerper*); // tauscht über Verwenden von obigen Methoden direkt die eingegebenen Koerper

              void tausch (List*, List*, List*, List*); // primitives Tausch, tauscht Zeiger



              double gesOberflaeinhalt ();

              double gesVolumen ();



              void ausgabe ();

};





List::List() { anker = 0; }



void List::add (geomKoerper* k) {

        List* p = anker;

        anker = new List;

        anker->figur = k;

        anker->next = p;

}





void List::loesch(geomKoerper* k) {



     /*Idee: Durchlaufen d. Liste von vorne nach hinten.



     Fall 1: Hierbei trifft man auf den Zeiger von k. Dann entferne

     man dieses Listenelement (es genügt, den Zeiger des

     Vorgängers auf den Nachfolger zu setzen -> "ausklinken").



     Fall 2: Das Element k ist in der Liste nicht enthalten, dann

     bleibt die Liste unverändert.

     */



     List* p = anker;

     List* q = NULL;



     while (p != 0 && p->figur != k) {

           q = p;

           p = p->next; //durchlaufen

     }



     if (p != 0) {

     //k also gefunden

             if (q == 0) {anker=0;} // Liste besteht nur aus k

             else {q->next = p->next;} // "ausklinken des Gelöschten"


     }



}



List* List::findK (geomKoerper* k) {



        List* p = anker;

        List* q = 0;



        while (p != 0 && p->figur != k) {

           q = p;

           p = p->next; //durchlaufen

    }


        if (p != 0) {

         //k also gefunden

             if (q == 0) {return p;} // Liste besteht nur aus k

             else {return p;} // p speichern, hier ist das gesuchte k


        }

        else { return 0; };

}




List* List::findvorK (geomKoerper* k) {

    // da die Liste einfach gerichtet verkettet ist

    // muss man sich dieser Funktion bedienen



        List* p = anker;

        List* q = NULL;



        while (p != 0 && p->figur != k) {

           q = p;

           p = p->next; //durchlaufen

        }


        if (p != 0) {

         //k also gefunden

               if (q == 0) {return 0;} // Liste besteht nur aus k

               else {return q;} // q als Zeiger vor k speichern

        }

        else { return 0; };

}





void List::tausch (List* zwei, List* acht, List* vorzwei, List* voracht) {



    List* h = acht->next;



    vorzwei->next = acht;

    acht->next = h->next;

    voracht = zwei;

    zwei->next = h;

}







void List::tauschK (geomKoerper* A, geomKoerper* B) {


    tausch (anker->findK(A), anker->findvorK(A), anker->findK(B), anker->findvorK(B));



}











double List::gesOberflaeinhalt() {

     List* p = anker;

     List* q = 0;

     double gesO = 0; // gesamter Oberflächeninhalt des Turms



     /* p und q laufen bis ans Ende durch die Liste,

        wobei p auf das jeweils betrachtete und q auf

        das unmittelbar vor p stehende Element zeigt.

        Für p=null zeigt q auf das letzte Elemente der Liste.

     */



     while (p != 0) {



           gesO = gesO + (p->figur)->getU_flaeinhalt() + (p->figur)->getO_flaeinhalt() + 0;

                /* 0 soll hier A_schnitt zwischen pfigur.o und pnextfigur.u sein, dessen Berechnung

                 nicht trivial ist, wie wenn sich beide nur ganz und nicht halb überschneiden.

                 Allgemein ist das aber nicht immer der Fall, siehe Entwurfsbeschreibung.

                 Es ist also eine Funktion f(p,q) zu bestimmen und als Methode zu implementieren.

                */

           q = p;

           p = p->next;



     }



     if (q != 0) {


          gesO = gesO + (q->figur)->getO_flaeinhalt();

     }



     else {gesO = 0;}



     return gesO;



}



double List::gesVolumen() {

     List* p = anker;

     List* q = 0;

     double gesV = 0;



     while (p != 0) {



           gesV = gesV + (p->figur)->getVolumen();



           q = p;

           p = p->next;



     }



     if (q != 0) {



          gesV = gesV + (q->figur)->getVolumen();

     }



     else {gesV = 0;}



     return gesV;



}



void List::ausgabe() {



     List* p = anker;

     List* q = 0;



     while (p != 0) {



           cout << (p->figur)->getVolumen() << endl;

           cout << (p->figur)->getOberflaeinhalt() << endl;

           cout << (p->figur)->getFarbe() << endl;



           q = p;

           p = p->next;



     }



      if (q != 0) {



          cout << (q->figur)->getVolumen() << endl;

          cout << (q->figur)->getOberflaeinhalt() << endl;

          cout << (q->figur)->getFarbe() << endl;



     }



     else cout << "leer" << endl;



}