Ableitungen mit virtuellen Konstruktoren

Im folgenden eine Musterlösung zu den Teilaufgaben aus Ableitungen mit virtuellen Konstruktoren.

// Time-stamp: "(05.12.01 14:45) kiste.cpp [Klaus Wachtler]"
//

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

using namespace std;


//
//  *   *  **          *
//  *  *               *
//  * *         ***    *     ***
//  **     *   *      ***   *   *
//  * *    *    ***    *    ****
//  *  *   *       *   *    *
//  *   *   *   ***     *    ***
//
//

class CKiste
{
public:

  CKiste( string Name = "?",
          double b = 0.0,
          double h = 0.0,
          double t = 0.0,
          string Material = "Luft"
          )
  {
    this->Name     = Name;
    this->b        = b;
    this->h        = h;
    this->t        = t;
    this->Material = Material;
  }

  CKiste( const CKiste &rechteSeite )
  {
    this->Name     = rechteSeite.Name;
    this->b        = rechteSeite.b;
    this->h        = rechteSeite.h;
    this->t        = rechteSeite.t;
    this->Material = rechteSeite.Material;
  }

  virtual CKiste *clone() const
  {
    return new CKiste( *this );
  }

  virtual ~CKiste()
  {
  }

  CKiste & operator=( const CKiste &rechteSeite )
  {
    this->Name     = rechteSeite.Name;
    this->b        = rechteSeite.b;
    this->h        = rechteSeite.h;
    this->t        = rechteSeite.t;
    this->Material = rechteSeite.Material;

    return *this;
  }

  virtual ostream &zeigdich( ostream &s ) const
  {
    s << Name
      << ", " << b
      << ", " << h
      << ", " << t
      << ", " << Material;

    return s;
  }

  // gibt alle Teile aus:
  friend ostream &operator<<( ostream &s, const CKiste &k );

protected:

  string   Name;
  double   b, h, t; // Breite, Höhe, Tiefe
  string   Material;

private:


}; // class CKiste

ostream &operator<<( ostream &s, const CKiste &k )
{
  return k.zeigdich( s );
}


//
//   ***         *            *                       *
//  *   *        *            *                       *
//  *            *            *           ***         *
//   ***    ***  ***   *   *  ****       *       ***  ***
//      *  *     *  *  *   *  *   *       ***   *     *  *
//  *   *  *     *  *  *   *  *   *  **      *  *     *  *  **
//   ***    ***  *  *   ****  ****   **   ***    ***  *  *  **
//
//

class CSchubladenschrank
  : public CKiste
{
public:

  CSchubladenschrank( string Name = "?",
                      double b = 0.0,
                      double h = 0.0,
                      double t = 0.0,
                      string Material = "Luft",
                      int ns = 0
                      )
    : CKiste( Name, b, h, t, Material )
  {
    this->AnzahlSchubladen = ns;
  }

  CSchubladenschrank( const CSchubladenschrank &rechteSeite )
    : CKiste( (CKiste)rechteSeite )
  {
    this->AnzahlSchubladen = rechteSeite.AnzahlSchubladen;
  }

  virtual CSchubladenschrank *clone() const
  {
    return new CSchubladenschrank( *this );
  }

  virtual ~CSchubladenschrank()
  {
  }

  CSchubladenschrank & operator=( const CSchubladenschrank &rechteSeite )
  {
    *(CKiste*)this = (CKiste)rechteSeite;
    this->AnzahlSchubladen = rechteSeite.AnzahlSchubladen;

    return *this;
  }

  virtual ostream &zeigdich( ostream &s ) const
  {
    ( CKiste(*this) ).zeigdich( s );
    s << ", Schubladen " << AnzahlSchubladen;
    return s;
  }

  // gibt alle Teile aus:
  friend ostream &operator<<( ostream &s, const CSchubladenschrank &k );

protected:

  int AnzahlSchubladen;

private:


}; // class CSchubladenschrank

// ostream &operator<<( ostream &s, const CSchubladenschrank &k )
// {
//   return k.zeigdich( s );
// }


//
//  *   *  *          **      *                             *
//  *  *   *                  *                             *
//  * *    *    ***           *   ***           ***         *
//  **     *   *   *  *    ****  *   *  ****   *       ***  ***
//  * *    *   ****   *   *   *  ****   *   *   ***   *     *  *
//  *  *   *   *      *   *   *  *      *          *  *     *  *  **
//  *   *   *   ***    *   ***    ***   *       ***    ***  *  *  **
//
//

class CKleiderschrank
  : public CKiste
{
public:

  CKleiderschrank( string Name = "?",
                      double b = 0.0,
                      double h = 0.0,
                      double t = 0.0,
                      string Material = "Luft",
                      int nt = 0
                      )
    : CKiste( Name, b, h, t, Material )
  {
    this->AnzahlTueren = nt;
  }

  CKleiderschrank( const CKleiderschrank &rechteSeite )
    : CKiste( (CKiste)rechteSeite )
  {
    this->AnzahlTueren = rechteSeite.AnzahlTueren;
  }

  virtual CKleiderschrank *clone() const
  {
    return new CKleiderschrank( *this );
  }

  virtual ~CKleiderschrank()
  {
  }

  CKleiderschrank & operator=( const CKleiderschrank &rechteSeite )
  {
    *(CKiste*)this = (CKiste)rechteSeite;
    this->AnzahlTueren = rechteSeite.AnzahlTueren;

    return *this;
  }

  virtual ostream &zeigdich( ostream &s ) const
  {
    ( (CKiste)*this ).zeigdich( s );
    s << ", Türen " << AnzahlTueren;
    return s;
  }

  // gibt alle Teile aus:
  friend ostream &operator<<( ostream &s, const CKleiderschrank &k );

protected:

  int AnzahlTueren;

private:


}; // class CKleiderschrank

// ostream &operator<<( ostream &s, const CKleiderschrank &k )
// {
//   return k.zeigdich( s );
// }



//
//  ****
//  *   *
//  *   *   ***
//  ****       *  *   *  *** **
//  *   *   ****  *   *  *  *  *
//  *   *  *   *  *   *  *  *  *
//  ****    ****   ****  *  *  *
//
//

class CKistenbaum
{
public:

  CKistenbaum()
  {
    pKiste = NULL;
  }

  void setzeKiste( const CKiste &k )
  {
    delete pKiste;
    pKiste = k.clone();
  }

  void setzeUO( const CKistenbaum &uo )
  {
    Unterobjekte.push_back( new CKistenbaum() );
    Unterobjekte[Unterobjekte.size()-1]->setzeKiste( (*uo.pKiste) );
  }

  virtual ~CKistenbaum()
  {
    delete pKiste;
  }

  void run()
  {
    if( pKiste )
      {
        cout << *pKiste << endl;
      }
    for( size_t i=0; i<Unterobjekte.size(); i++ )
      {
        Unterobjekte[i]->run();
      }
  }

  friend ostream &operator<<( ostream &s, CKistenbaum &k );

protected:

  CKiste  *pKiste;

  vector<CKistenbaum*>   Unterobjekte;

private:


}; // class CKistenbaum


ostream &operator<<( ostream &s, CKistenbaum &k )
{
  if( k.pKiste )
    {
      s << *(k.pKiste);
    }
  return s;
}

int main( int nargs, char **args )
{
  // Wurzel des Baums:
  CKistenbaum wurzel;
  wurzel.setzeKiste( CKiste( "Wurzel", 500, 360, 400, "Luft" ) );


  // Unterobjekte einfügen:

  CKistenbaum tmp;

  tmp.setzeKiste( (CSchubladenschrank( "Holzschrank",
                                       80,
                                       85,
                                       60,
                                       "Holz",
                                       5
                                       )
                   )
                  );
  wurzel.setzeUO( tmp );

  tmp.setzeKiste( (CKleiderschrank( "dretüriger Kleiderschrank",
                                    180,
                                    200,
                                    60,
                                    "Span",
                                    3
                                    )
                   )
                  );
  wurzel.setzeUO( tmp );

  tmp.setzeKiste( (CSchubladenschrank( "sieben Schubladen",
                                       80,
                                       85,
                                       40,
                                       "Blech",
                                       7
                                       )
                   )
                  );
  wurzel.setzeUO( tmp );

  // alles ausgeben:
  wurzel.run();


  return 0;
} // main( int nargs, char **args )