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> CCoffeeDecorator( CCoffeeComponent* pComponent = 0) : CCoffeeComponent(), m_pComponent( pComponent ) {};
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;
}
