Constructor Behavior

Hi.

I am learning Design Patterns so I pulled this piece of code off the
ng (decorator) . Now I am going through it with the debugger and
seeing what does what and I have found something I just don't
understand.

The constructor for CCoffeeDecorator has this in the list
CCoffeeComponent().


I see it hitting the CCoffeeComponent() constructor ... but I can't
figure out what this accomplishes. The only thing I can think of, is
that this sets the pointer type to CCoffeeComponent ... but I don't
understand the mechanics are behind it.

Randy

#include <iostream>
#include <string>

using namespace std;

/*
*******************************************************************************************************
    abstract base class ** normal - any class can be decorated.
    hide constructor prevent construction of a plain component
*
********************************************************************************************************/
class CCoffeeComponent {
public:
  virtual string Info() = 0;

protected:
  CCoffeeComponent () {};
  string m_Info;
};

/*
*******************************************************************************************************
    Furthermore we need a decorator class that "is-a" component and
stores a
    pointer to a passed component object:
    NOTE: the default NULL-pointer that is used as an end-marker of
the component chain
*
********************************************************************************************************/
class CCoffeeDecorator : public CCoffeeComponent {
public:
  CCoffeeDecorator( CCoffeeComponent* pComponent = 0) :
CCoffeeComponent(), m_pComponent( pComponent ) {};

public:
  virtual string Info() {
                           if( !m_pComponent )
                             return string("");

                            return m_pComponent->Info();
                          }; // delegate info call to actual
implementation

protected:
  CCoffeeComponent* m_pComponent;

};

//This base implementation of the decorator delegates any Info() calls
to its
//wrapped component if there is any. In principle we've got the tools
to
//create different component combinations at our fingertips. Now we
get down
//the some sample component implementations:

// create different decorator implementations
class CEspresso: public CCoffeeDecorator
{
public:
  CEspresso( CCoffeeComponent* pComponent = 0) :
CCoffeeDecorator(pComponent ) {};
  // extend info implementation and delegate to base class
  string Info() { return CCoffeeDecorator::Info() + string("
espresso"); };
};

// create different decorator implementations
class CSteamedMilk: public CCoffeeDecorator
{
public:
  CSteamedMilk( CCoffeeComponent* pComponent = 0) :
CCoffeeDecorator(pComponent ) {};
  // extend info implementation and delegate to base class
  string Info() { return CCoffeeDecorator::Info() + string(" steamed
milk"); };
};

// create different decorator implementations
class CFoamedMilk: public CCoffeeDecorator
{
public:
  CFoamedMilk( CCoffeeComponent* pComponent = 0) :
CCoffeeDecorator(pComponent ) {};
  // extend info implementation and delegate to base class
  string Info() { return CCoffeeDecorator::Info() + string(" foamed
milk"); };
};

class CSugar: public CCoffeeDecorator
{
public:
  CSugar( CCoffeeComponent* pComponent = 0) :
CCoffeeDecorator( pComponent ){};
  // extend info implementation and delegate to base class
  string Info() { return CCoffeeDecorator::Info() + string("
sugar"); };
};

class CMug: public CCoffeeDecorator
{
public:
  CMug( CCoffeeComponent* pComponent = 0) :
CCoffeeDecorator( pComponent ){};
  // extend info implementation and delegate to base class
  string Info() {
      return CCoffeeDecorator::Info() + string(" mug");
  };
};

int main()
{
/*
    The pointer type is component, however the object type is
Decorator. This is the
    jist of virtual/polymorphism.

    The recursion here is because the constructor for the decorator is
*/
  CCoffeeComponent* pCappucino= new CEspresso( new CSugar( new
CFoamedMilk( new CMug) ) );
  CCoffeeComponent* pMocca = new CEspresso( new CSugar( new CMug ) );
  CCoffeeComponent* pEmpty = new CMug;

  cout << "Cappucino components: ";
  cout << pCappucino->Info() << endl;
  cout << "Mocca components: ";
  cout << pMocca->Info() << endl;
  cout << "Empty components: ";
  cout << pEmpty->Info() << endl;

  delete pCappucino;
  delete pMocca;

    system("PAUSE");
    return EXIT_SUCCESS;

  return 0;

}