ccplusplus.com: Design Pattern Sample Code

Showing posts with label Design Pattern Sample Code. Show all posts

Saturday, January 14, 2012

adapter design pattern c++ example

/*******************************************************************
 * File         :   adapter-design-pattern.cpp
 * Author       :   Saurabh Gupta
 * Description  :   adapter design pattern c++ example
 *                 Convert one class so that it appears to be another class.
 * Date         :   PM 02:51 14 January 2012
 * Source       :   http://www.ccplusplus.com/2011/07/design-pattern-guide-with-example-and.html
 * Note         :   
 *******************************************************************/
 
 #include <iostream>

class CRoundShape
 {
    public:
        virtual ~CRoundShape() { }
        virtual void m_doRound() const=0;
 };

class CSquareShape
 {
    public:
        virtual ~CSquareShape() { }
        virtual void m_doSquare() const=0;
 };

class CRound_Hole
 {
     public:
        void m_insert(const CRoundShape & shape) const
        {
            shape.m_doRound();
        }
 };

class CSquareShapeAdapter : public CRoundShape
 {
     private:
        CSquareShape & square_shape;
     public:
        CSquareShapeAdapter(CSquareShape & shape) : square_shape(shape){ }
        void m_doRound() const
        {
            square_shape.m_doSquare();
        }
 };

class CDisplayMessage : public CSquareShape
 {
     public:
        void m_doSquare() const
        {
            std::cout << "ccplusplus.com" << std::endl;
        }
 };

void display_message(const CRoundShape & shape)
 {
 CRound_Hole().m_insert(shape);
 }

int main()
 {
 CDisplayMessage shape;
 display_message(CSquareShapeAdapter(shape));
 return 0;
 }

/*
 * OUTPUT
 *
 [sgupta@rhel6x64 adapter]$ c++ adapter-design-pattern.cpp -o adapter-design-pattern
 [sgupta@rhel6x64 adapter]$ ./adapter-design-pattern
 ccplusplus.com
 [sgupta@rhel6x64 adapter]$
*/

  Note:

  display-message.cpp that is used to explain the
design pattern

See Also:

  Design pattern Concept and Sample Codes

Tuesday, January 10, 2012

abstract factory pattern in c++ example

/***************************************************************************************
 * File         :   abstract-factory.cpp
 * Author       :   Saurabh Gupta
 * Description  :   abstract factory pattern in c++ example
 *              :   An abstract factory is used to create objects.  However you want to
 *                  change what object is created.
 * Date         :   AM 09:13 04 january 2012
 * Source       :   http://www.ccplusplus.com/2011/07/design-pattern-guide-with-example-and.html
 * Note         :   
 ***************************************************************************************/
 #include <iostream>
 #include <string>
 #include <memory>

using namespace std;
 
 class CMessage {
     public:
        virtual ~CMessage() { }
        virtual string m_getMessage()=0;
 };

class CAbstractFactoryMessage {
     public:
        virtual ~CAbstractFactoryMessage() { }
        virtual auto_ptr<CMessage> m_createMessage() const=0;
 };

class CDisplayMessage : public CMessage {
     public:
        string m_getMessage() {
            return "www.ccplusplus.com";
        }
 };

class CDisplayMessageFactory : public CAbstractFactoryMessage {
     public:
        std::auto_ptr<CMessage> m_createMessage() const {
            return std::auto_ptr<CMessage>(new CDisplayMessage());
        }
 };

void display_message(const CAbstractFactoryMessage & factory) {
     auto_ptr<CMessage> message = factory.m_createMessage();
     cout << message->m_getMessage() << std::endl;
 }

int main() {
 display_message(CDisplayMessageFactory());
 return 0;
 }
/*
 * OUTPUT
 *
 [sgupta@rhel55x86 design-pattern]$ c++ abstract-factory.cpp -o abstract-factory
 [sgupta@rhel55x86 design-pattern]$ ./abstract-factory
 www.ccplusplus.com
 [sgupta@rhel55x86 design-pattern]$
*/

Note:

display-message.cpp that is used to explain the
design pattern

See Also:

  Design pattern Concept and Sample Codes

Monday, January 9, 2012

visitor pattern in c++ example

/***************************************************************************************
 * File         :   visitor-pattern.cpp
 * Author       :   Saurabh Gupta
 * Description  :   visitor pattern in c++ example
 *                  Visitor Pattern provides a call-back for every item in a collection.  
 *                  This allows the implementation of the collection to hidden. 
 * Date         :   PM 04:05 09 January 2012
 * Source       :   http://www.ccplusplus.com/2011/07/design-pattern-guide-with-example-and.html
 * Note         :   
 ***************************************************************************************/
 #include <vector>
 #include <string>
 #include <iostream>

using namespace std;
 
 class CVisitorPattern
 {
     public:
        virtual ~CVisitorPattern() { 
        }
        virtual void m_atRecipient(const string &)=0;
 };

class CRecipient
 {
        vector<string> recipients;
     public:
        void mAddRecipient(const string & recipient) {
            recipients.push_back(recipient);
        }
        void m_visit(CVisitorPattern & visitor) const {
            for(vector<string>::const_iterator recipient = recipients.begin();
                recipient != recipients.end(); 
                ++recipient) {
                visitor.m_atRecipient(*recipient);
            }
        }
 };

class whereAreWe : public CVisitorPattern {
     public:
        void m_atRecipient(const string & recipient) {
            cout << "www." << recipient << endl;
        }
 };

void display_message(CVisitorPattern & visitor) {
 CRecipient recipients;
 recipients.mAddRecipient("ccplusplus.com");
 recipients.m_visit(visitor);
 }

int main() {
 whereAreWe visitor;
 display_message(visitor);
 return 0;
 }
/*
 * OUTPUT
 *
 [sgupta@rhel6x64 visitor]$ c++ visitor-pattern.cpp -o visitor-pattern
 [sgupta@rhel6x64 visitor]$ ./visitor-pattern
 www.ccplusplus.com
 [sgupta@rhel6x64 visitor]$
 */

Note:

display-message.cpp that is used to explain the
design pattern

See Also:

  Design pattern Concept and Sample Codes

Thursday, January 5, 2012

template method pattern c++ example

/*******************************************************************
 * File         :   template-method-pattern.cpp
 * Author       :   Saurabh Gupta
 * Description  :   template method pattern c++ example
 *                  Template method provides an implementation 
 *                  in a derived class, to be used by the base class.
 * Date         :   PM 08:32 05 January 2012
 * Source       :   http://www.ccplusplus.com/2011/07/design-pattern-guide-with-example-and.html
 * Note         :   
 *******************************************************************/
 
 #include <string>
 #include <iostream>

using namespace std;
 
 class Cccplusplus {
     public:
        virtual ~Cccplusplus() {
        }
        void output() {
            m_write("ccplusplus.com");
            m_writeendl();
        };
        virtual void m_write(const std::string &)=0;
        virtual void m_writeendl()=0;
 };

class CccplusplusTemplate : public Cccplusplus{
     public:
        void m_write(const std::string & str){
            cout << str;
        }
        void m_writeendl(){ 
            cout << endl; 
        }
 };

void display_message(Cccplusplus & ccpp){
 ccpp.output();
 }

int main() {
 CccplusplusTemplate ccpp;
 display_message(ccpp);
 return 0;
 }

/*
 * OUTPUT
 *
 [sgupta@rhel55x86 template-method]$ c++ template-method-pattern.cpp -o template-method-pattern
 [sgupta@rhel55x86 template-method]$ ./template-method-pattern
 ccplusplus.com
 [sgupta@rhel55x86 template-method]$
*/

See Also:

Design pattern Concept and Sample Codes

strategy pattern in c++ example

/*******************************************************************
 * File         :   strategy-pattern.cpp
 * Author       :   Saurabh Gupta
 * Description  :   strategy pattern in c++ example
 *                  Strategy is an algorithm that you pass into a 
 *                  function or class that uses the strategy.  The 
 *                  idea is that you can provide a different strategy 
 *                  to achieve something different.
 * Date         :   PM 08:11 05 January 2012
 * Source       :   http://www.ccplusplus.com/2011/07/design-pattern-guide-with-example-and.html
 * Note         :   
 *******************************************************************/
 
 #include <iostream>
 #include <string>

using namespace std;
 
 class CStrategyPattern {
     public:
        virtual ~CStrategyPattern() {
        }
        virtual string m_format(const string &, const string &) const=0;
 };

class Formatter : public CStrategyPattern {
     public:
        string m_format(const string & s1, const string & s2) const
        {
            return s1 + "" + s2 + "";
        }
 };

void display_message(const CStrategyPattern & strategy){
 cout << strategy.m_format("c", "cplusplus.com") << endl;
 }

int main() {
 display_message(Formatter());
 return 0;
 }
 
/*
 * OUTPUT
 *
 [sgupta@rhel55x86 strategy]$ c++ strategy-pattern.cpp -o strategy-pattern
 [sgupta@rhel55x86 strategy]$ ./strategy-pattern
 ccplusplus.com
 [sgupta@rhel55x86 strategy]$
*/

See Also:

Design pattern Concept and Sample Codes

Wednesday, January 4, 2012

state design pattern in c++

/*******************************************************************
 * File         :   state-pattern.cpp
 * Author       :   Saurabh Gupta
 * Description  :   state design pattern c++
 *                  State is like an enum, but we can define different 
 *                  behaviour for each state. We could add another class,
 *                  Sad, which did something entirely different when asked to m_talk().
 * Date         :   PM 07:47 04 January 2012
 * Source       :   http://www.ccplusplus.com/2011/07/design-pattern-guide-with-example-and.html
 * Note         :   
 *******************************************************************/
 
 #include <iostream>

using namespace std;
 
 class CBehaviour {
     public:
        virtual ~CBehaviour() { 
        }
        virtual void m_talk()=0;
 };

class CFriendly : public CBehaviour {
     public:
        void m_talk() { 
            cout << "www.ccplusplus.com" << endl; 
        }
 };

void display_message(CBehaviour & mood){
 mood.m_talk();
 }

int main(){
 CFriendly mood;
 display_message(mood);
 return 0;
 }
/*
 * OUTPUT
 *
 [sgupta@rhel55x86 state]$ c++ state-pattern.cpp -o state-pattern
 [sgupta@rhel55x86 state]$ ./state-pattern
 www.ccplusplus.com
 [sgupta@rhel55x86 state]$
 */

See Also:

Design pattern Concept and Sample Codes

design pattern prototype c++ example

/***************************************************************************************
 * File         :   prototype-pattern.cpp
 * Author       :   Saurabh Gupta
 * Description  :   prototype design pattern example c++
 *                  A Prototype is an object which is cloneable, i.e. you can create a 
 *                  copy, even though you don't know what you are creating a copy of.
 * Date         :   AM 11:13 04 january 2012
 * Source       :   http://www.ccplusplus.com/2011/07/design-pattern-guide-with-example-and.html
 * Note         :   
 ***************************************************************************************/
 #include <iostream>
 #include <memory>

class CPrototypeOperation
 {
    public:
        virtual ~CPrototypeOperation() { }
        virtual std::auto_ptr<CPrototypeOperation> clone() const=0;
        virtual void m_Display()=0;
 };

class CDisplayMessage : public CPrototypeOperation
 {
    public:
        std::auto_ptr<CPrototypeOperation> clone() const
        {
            return std::auto_ptr<CPrototypeOperation>(new CDisplayMessage);
        }
        void m_Display()
        {
            std::cout << "www.ccplusplus.com" << std::endl;
        }
 };

void display_message(const CPrototypeOperation & something)
 {
 std::auto_ptr<CPrototypeOperation> clone = something.clone();
 clone->m_Display();
 }

int main()
 {
 display_message(CDisplayMessage());
 return 0; 
 }

/*
 * OUTPUT
 *
 [sgupta@rhel6x64 prototype]$ c++ prototype-pattern.cpp -o prototype-pattern
 [sgupta@rhel6x64 prototype]$ ./prototype-pattern
 www.ccplusplus.com
 [sgupta@rhel6x64 prototype]$
 */

See Also:

Design pattern Concept and Sample Codes

observer design pattern c++ example

/***************************************************************************************
 * File         :   observer-pattern.cpp
 * Author       :   Saurabh Gupta
 * Description  :   observer design pattern example c++
 *              :   Observer is used to watch events on another object.
 *                  Here, the CWriterBoard class keeps an eye on the CMessageBoard class, 
 *                  and writes the message each time CMessageBoard::m_post() is called.
 * Date         :   AM 09:13 04 january 2012
 * Source       :   http://www.ccplusplus.com/2011/07/design-pattern-guide-with-example-and.html
 * Note         :   
 ***************************************************************************************/
#include <iostream>
#include <string>

class CObserverPattern
 {
  public:
  virtual ~CObserverPattern() { 
  }
  virtual void m_OnMessage(const std::string &)=0;
 };

class CMessageBoard
 {
  private:
  CObserverPattern & observer;
  public:
  CMessageBoard(CObserverPattern & obs) : observer(obs) { }

void m_post(const std::string & str)
  {
   observer.m_OnMessage(str);
  };
 };

class CWriterBoard : public CObserverPattern
  {
  public:
  void m_OnMessage(const std::string & str)
  {
   std::cout << str << std::endl;
  }
 };

void display_message(CMessageBoard & msgb)
 {
 msgb.m_post("www.ccplusplus.com");
 }

int main()
 {
 CWriterBoard writer;
 CMessageBoard msgb(writer);
 display_message(msgb);
 return 0;
 }
/*
 * OUTPUT
 *
 [sgupta@rhel6x64 observer]$ c++ observer-pattern.cpp -o observer-pattern
 [sgupta@rhel6x64 observer]$ ./observer-pattern
 www.ccplusplus.com
 [sgupta@rhel6x64 observer]$
 */

See Also:

Design pattern Concept and Sample Codes

Sunday, January 1, 2012

momento design pattern example c++

/*******************************************************************
 * File         :   momento-pattern.cpp
 * Author       :   Saurabh Gupta
 * Description  :   momento design pattern c++
 *                  memento stores a previous state or value so 
 *                  that it can be restored at a later time.
 * Date         :   PM 10:53 01 January 2012
 * Source       :   http://www.ccplusplus.com/2011/07/design-pattern-guide-with-example-and.html
 * Note         :   
 *******************************************************************/
 #include <iostream>
 #include <string>

using namespace std;
 
 class CMementoPattern
 {
     private:
        string m_strOldString;
     public:
        CMementoPattern(string & strString, const string strTempString) : m_strOldString(strString)
        {
            strString = strTempString;
        }
        void revert(string & strString)
        {
            strString = m_strOldString;
        }
 };

void ccplusplus(CMementoPattern & memento)
 {
 string strMessage;
 memento.revert(strMessage);
 cout << strMessage << endl;
 }

int main()
 {
 string hw("c cplusplus");
 CMementoPattern mem(hw, "Goodbye, Saurabh");
 ccplusplus(mem);
 return 0;
 }
/*
 * OUTPUT
 *
 [sgupta@rhel55x86 momemto]$ c++ momento-pattern.cpp -o momento-pattern
 [sgupta@rhel55x86 momemto]$ ./momento-pattern
 c cplusplus
 [sgupta@rhel55x86 momemto]$
*/

See Also:

Design pattern Concept and Sample Codes

mediator pattern example

/*******************************************************************
 * File         :   mediator-pattern.cpp
 * Author       :   Saurabh Gupta
 * Description  :   mediator design pattern example c++
 *                  CMediatorPattern binds different classes together, and 
 *                  the individual classes communicate via the mediator, 
 *                  never directly.  In this example, CMessage::m_print() 
 *                  calls CMediatorPattern, not CPrinter directly.
 * Date         :   PM 10:37 01 January 2012
 * Source       :   http://www.ccplusplus.com/2011/07/design-pattern-guide-with-example-and.html
 * Note         :   
 *******************************************************************/
 #include <iostream>
 #include <string>

using namespace std;
 
 class CPrinter
 {
     public:
        void m_print(const string & str) const
        {
            cout << str << endl;
        }
 };

class CMessage
 {
     public:
        virtual ~CMessage() { }
        virtual void m_print(const class CMediatorPattern & mediator) const;
 };

class CMediatorPattern
 {
     private:
        const CPrinter & printer;
        const CMessage & message;
     public:
        CMediatorPattern(const CPrinter & pr, const CMessage & msg) :
            printer(pr),
            message(msg) { }
        void m_print() const
        {
            message.m_print(*this);
        }
        void m_print(const string & str) const
        {
            printer.m_print(str);
        }
 };

void CMessage::m_print(const CMediatorPattern & mediator) const
 {
 mediator.m_print("Hello world!");
 }

void helloworld(const CMediatorPattern & mediator)
 {
 mediator.m_print();
 }

int main()
 {
 CPrinter printer;
 CMessage message;
 helloworld(CMediatorPattern(printer,message));
 return 0;
 }
/*
 * OUTPUT
 *
 [sgupta@rhel55x86 mediator]$ c++ mediator-pattern.cpp -o mediator-pattern
 [sgupta@rhel55x86 mediator]$ ./mediator-pattern
 Hello world!
 [sgupta@rhel55x86 mediator]$
 */

See Also:

Design pattern Concept and Sample Codes

mediator design pattern c++ examples

using namespace std;
 
 class CPrinter
 {
     public:
        void m_print(const string & str) const
        {
            cout << str << endl;
        }
 };

class CMessage
 {
     public:
        virtual ~CMessage() { }
        virtual void m_print(const class CMediatorPattern & mediator) const;
 };

void CMessage::m_print(const CMediatorPattern & mediator) const
 {
 mediator.m_print("Hello world!");
 }

void helloworld(const CMediatorPattern & mediator)
 {
 mediator.m_print();
 }

See Also:

Design pattern Concept and Sample Codes

Friday, December 30, 2011

iterator design pattern example

/*******************************************************************
 * File         :   iterator-pattern.cpp
 * Author       :   Saurabh Gupta
 * Description  :   iterator design pattern example c++
 * Date         :   PM 07:09 30 December 2011
 * Source       :   http://www.ccplusplus.com/2011/07/design-pattern-guide-with-example-and.html
 * Note         :   
 ******************************************************************/
 #include <iostream>
 #include <cstring>

using namespace std;

class CStringIteratorPattern
 {
     private:
        const char *m_cposition, *m_cend;
     public:
        CStringIteratorPattern(const char * str) : m_cposition(str), m_cend(str + strlen(str))  { 
        }
        bool at_end() const { 
            return m_cposition == m_cend; 
        }
        void m_advance() { 
            ++m_cposition; 
        }
        char m_getchar() const {
            return *m_cposition; 
        }
 };

void helloworld(CStringIteratorPattern & iterator)
 {
 for(CStringIteratorPattern i=iterator; !i.at_end(); i.m_advance())
 {
  cout << i.m_getchar();
 } 
 }

int main()
 {
 CStringIteratorPattern iterator("Hello world!\n");
 helloworld(iterator);
 return 0;
 }

/*
 * OUTPUT
 *
 [sgupta@rhel6x64 iterator]$ c++ iterator-pattern.cpp -o iterator-pattern
 [sgupta@rhel6x64 iterator]$ ./iterator-pattern
 Hello world!
 [sgupta@rhel6x64 iterator]$
 */

See Also:

Design pattern Concept and Sample Codes

Thursday, December 29, 2011

proxy design pattern example

/*******************************************************************
 * File         :   procy-pattern.cpp
 * Author       :   Saurabh Gupta
 * Description  :   Proxy allows one object to stand for something else. 
 *                  So whilst you think you are dealing with one object, 
 *                  you are actually dealing with something else.  
 *                  In this example, CProxyPattern stands for cout.
 * Date         :   PM 05:45 29 December 2011
 * Source       :   http://www.ccplusplus.com/2011/07/design-pattern-guide-with-example-and.html
 * Note         :   
 ******************************************************************/
 
 #include <iostream>
 #include <string>

using namespace std;
 
 class CProxyPattern
 {
 public:
 void write(const string & str) const
 {
  cout << str;
 }
 };

void helloworld(const CProxyPattern & cout)
 {
 cout.write("Hello world!\n");
 }

int main()
 {
 helloworld(CProxyPattern());
 return 0;
 }
/*
 * OUTPUT
 *
 [sgupta@rhel6x64 interpreter]$ c++ interpreter-pattern.cpp -o interpreter-pattern
 [sgupta@rhel6x64 interpreter]$ ./interpreter-pattern
 Hello world! 
 [sgupta@rhel6x64 interpreter]$ 
 */

See Also:

Design pattern Concept and Sample Codes

interpreter design pattern example

/*******************************************************************
 * File         :   interpreter-pattern.cpp (interpreter design pattern example)
 * Author       :   Saurabh Gupta
 * Description  :   CInterpreter processes commands and performs actions 
 *                  based on its input. Here we create a simple command
 *                  language consisting of single characters.
 * Date         :   PM 05:20 29 December 2011
 * Source       :   http://www.ccplusplus.com/2011/07/design-pattern-guide-with-example-and.html
 * Note         :   
 ******************************************************************/
 #include <string>
 #include <iostream>
 #include <stdexcept>

using namespace std;
 
 class CInterpreter
 {
     public:
        template<typename It>
        void run(It from, It to)
        {
            for(It i=from; i!=to; ++i)
            {
                switch(*i)
                {
                    case 'h':
                        cout << "Hello";  
                        break;
                    case ' ': 
                        cout << ' ';   
                        break;
                    case 'w': 
                        cout << "world";  
                        break;
                    case '!': 
                        cout << '!';   
                        break;
                    case 'n': 
                        cout << endl; 
                        break;
                    default:  
                    throw runtime_error("Unknown command");
                }
            }
        }
 };

void helloworld(const string & script)
 {
 CInterpreter().run(script.begin(), script.end());
 }

int main()
 {
 helloworld("h w!n");
 return 0;
 }
/*
 * OUTPUT
 *
 [sgupta@rhel6x64 interpreter]$ c++ interpreter-pattern.cpp -o interpreter-pattern
 [sgupta@rhel6x64 interpreter]$ ./interpreter-pattern
 Hello world! 
 [sgupta@rhel6x64 interpreter]$ 
 */

See Also:

Design pattern Concept and Sample Codes

Tuesday, December 27, 2011

flyweight design pattern example

/*******************************************************************
 * File         :   flyweight-pattern.cpp
 * Author       :   Saurabh Gupta
 * Description  :   flyweight design pattern c++
 * Date         :   PM 10:33 27 December 2011
 * Source       :   http://www.ccplusplus.com/2011/07/design-pattern-guide-with-example-and.html
 * Note         :   
 ******************************************************************/
 #include <iostream>
 #include <string>
 #include <algorithm>

using namespace std;
 
 class CFlyWeight
 {
    private:
        char m_cCh;
    public:
        CFlyWeight(char c) : m_cCh(c)
        {
        }
        void m_OutPut() const
        { 
            cout << m_cCh; 
        }
 };

struct OutputChar
 {
 void operator()(char m_cCh) const
 {
  CFlyWeight(m_cCh).m_OutPut();
 }
 };

void helloworld(const string & message)
 {
 for_each(message.begin(), message.end(), OutputChar());
 }

int main()
 {
 helloworld("Hello world!\n");
 return 0;
 }
/*
 * OUTPUT
 *
 [sgupta@rhel6x64 flyweight]$ c++ flyweight-pattern.cpp -o flyweight-pattern
 [sgupta@rhel6x64 flyweight]$ ./flyweight-pattern
 Hello world!
 [sgupta@rhel6x64 flyweight]$
 */

See Also:

Design pattern Concept and Sample Codes

Saturday, December 24, 2011

factory method design pattern example

/*******************************************************************
 * File         :   factory-method.cpp
 * Author       :   Saurabh Gupta
 * Description  :   factory method in c++
 * Date         :   PM 11:10 24 December 2011
 * Source       :   http://www.ccplusplus.com/2011/07/design-pattern-guide-with-example-and.html
 * Note         :   
 ******************************************************************/
 
#include <iostream>
#include <string>

using namespace std;

class CFactoryMethod
{
public:
    CFactoryMethod() { 
    }
    virtual ~CFactoryMethod() { 
    }
    virtual string m_getMessage()=0;
    void m_greet(){
        cout << m_getMessage() << endl;
    }
};

class CHelloWorld : public CFactoryMethod {
    public:
        string m_getMessage() {
        return "Hello world!";
    }
};

void helloworld(CFactoryMethod & greeter) {
    greeter.m_greet();
}

int main() {
    CHelloWorld greeter;
    helloworld(greeter);
    return 0;
}
/*
 * OUTPUT
 *
 [sgupta@rhel6x64 factory_method]$ c++ factory-method.cpp -o factory-method
 [sgupta@rhel6x64 factory_method]$ ./factory-method
 Hello world!
 [sgupta@rhel6x64 factory_method]$ 
 */

See Also:

Design pattern Concept and Sample Codes

facade pattern example

/*******************************************************************
 * File         :   facade-pattern.cpp
 * Author       :   Saurabh Gupta
 * Description  :   facade pattern example in c++
 * Date         :   AM 09:30 24 December 2011
 * Source       :   http://www.ccplusplus.com/2011/07/design-pattern-guide-with-example-and.html
 * Note         :   
 ******************************************************************/
#include <string>
#include <iostream>

class CHelloWorld {
    public:
        virtual ~CHelloWorld() { 
        }
        virtual std::string m_hello()=0;
        virtual std::string m_world()=0;
        virtual void m_output(const std::string&)=0;
        virtual void endl()=0;
};

class FacadePattern : public CHelloWorld {
    public:
        std::string m_hello() { 
            return "Hello"; 
        }
        std::string m_world() { 
            return "world"; 
        }
        void m_output(const std::string & str){
            std::cout << str;
        }
        void endl(){
            std::cout << std::endl;
        }
};

void displayHelloWorld(CHelloWorld & hw) {
 hw.m_output(hw.m_hello());
 hw.m_output(" ");
 hw.m_output(hw.m_world());
 hw.m_output("!");
 hw.endl();
}

int main() {
 FacadePattern hw;
 displayHelloWorld(hw);
 return 0;
}
/*
 *
 *
 [sgupta@rhel6x64 facade]$ c++ facade-pattern.cpp -o facade-pattern
 [sgupta@rhel6x64 facade]$ ./facade-pattern
 Hello world!
 [sgupta@rhel6x64 facade]$ 
 */

See Also:

Design pattern Concept and Sample Codes

Friday, December 23, 2011

decorator design pattern c++ example

/*******************************************************************
 * File         :   decorator-pattern.cpp
 * Author       :   Saurabh Gupta
 * Description  :   decorator design pattern example c++
 * Date         :   AM 09:13 23 December 2011
 * Source       :   http://www.ccplusplus.com/2011/07/design-pattern-guide-with-example-and.html
 * Note         :   
 *******************************************************************/
 #include <iostream>
 #include <string>

using namespace std;
 
 class CGreeting {
    public:
        virtual ~CGreeting() { 
        }
        virtual string m_getGreeting() const=0;
 };

class CExclamation : public CGreeting {
    private:
        const CGreeting & greeting;
    public:
        CExclamation(const CGreeting & gr) : greeting(gr) { }
        string m_getGreeting() const {
            return greeting.m_getGreeting() + "!";
        }
 };

class CHelloWorld : public CGreeting {
    public:
        string m_getGreeting() const {
            return "Hello world";
        }
 };

void helloworld(const CGreeting & greeting) {
 cout << greeting.m_getGreeting() << endl;
 }

int main() {
 CHelloWorld hw;
 helloworld(CExclamation(hw));
 return 0;
 }
/*
 * OUTPUT
 *
-rw-rw-r--. 1 sgupta sgupta 637 Dec 23 08:57 decorator-pattern.cpp
 [sgupta@rhel6x64 decorator]$ c++ decorator-pattern.cpp -o decorator-pattern
 [sgupta@rhel6x64 decorator]$ ./decorator-pattern
 Hello world!
 [sgupta@rhel6x64 decorator]$
 */

Thursday, December 22, 2011

composite design pattern example

/*******************************************************************
 * File         :   composite-pattern.cpp
 * Author       :   Saurabh Gupta
 * Description  :   composite design pattern example c++
 * Date         :   PM 09:56 22 December 2011
 * Source       :   http://www.ccplusplus.com/2011/07/design-pattern-guide-with-example-and.html
 * Note         :   
 ******************************************************************/
#include <iostream>
#include <string>

class CGreeting
{
    public:
        virtual ~CGreeting() {
    }
 virtual std::string m_getGreeting()=0;
};

class CRecipient
{
    public:
        virtual ~CRecipient() { 
        }
        virtual std::string m_getRecipient()=0;
};

class CComposite
{
    private:
        CGreeting & greeting;
        CRecipient & recipient;
    public:
        CComposite(CGreeting & greeting, CRecipient & recipient) :
     greeting(greeting),
  recipient(recipient) { 
        }
        void greet() const {
            std::cout << greeting.m_getGreeting() << " " 
   << recipient.m_getRecipient() << "!" << std::endl;
        }
};

class CHello : public CGreeting
{
    public:
        std::string m_getGreeting() { 
            return "CHello"; 
        }
};

class CWorld : public CRecipient
{
    public:
        std::string m_getRecipient() { return "world"; }
};

void HelloWorld(const CComposite & composite)
{
 composite.greet();
}

int main()
{
 CHello hello;
 CWorld world;
 HelloWorld(CComposite(hello, world));
 return 0;
}
/*
 * OUTPUT
 *
 [sgupta@rhel6x64 composite]$ c++ composite-pattern.cpp -o composite-pattern
 [sgupta@rhel6x64 composite]$ ./composite-pattern
 CHello world!
 [sgupta@rhel6x64 composite]$ 
 */

command design pattern example

/*******************************************************************
 * File         :   command-pattern.cpp
 * Author       :   Saurabh Gupta
 * Description  :   command design pattern in c++
 * Date         :   PM 07:32 22 December 2011
 * Source       :   http://www.ccplusplus.com/2011/07/design-pattern-guide-with-example-and.html
 * Note         :   
 ******************************************************************/
#include <vector>
#include <algorithm>
#include <iostream>

class CCommandPattern
{
   public:
     virtual ~CCommandPattern() { 
     }
     virtual void m_execute()=0;
};

class CDisplayHello : public CCommandPattern
{
   public:
      void m_execute() {
          std::cout << "Hello ";
      }
};

class CDisplayWorld : public CCommandPattern
{
   public:
   void m_execute(){
      std::cout << "world!" << std::endl;
   }
};

class Commands
{
   private:
      std::vector<CCommandPattern*> commands;
      struct ExecuteCommand {
         void operator()(CCommandPattern * cmd) {
           cmd->m_execute();
         }
      };
   public:
      void add_command(CCommandPattern & cmd){
         commands.push_back(&cmd);
      }
      void m_execute() {
         std::for_each(commands.begin(), commands.end(), ExecuteCommand());
      }
};

void HelloWorld(Commands & commands) {
   commands.m_execute();
}

int main(){
   Commands commands;
   CDisplayHello hello;
   CDisplayWorld world;
   commands.add_command(hello);
   commands.add_command(world);
   HelloWorld(commands);
   return 0;
}
/*
 * OUTPUT
 *
 [sgupta@rhel6x64 command]$ c++ command-pattern.cpp -o command-pattern
 [sgupta@rhel6x64 command]$ ./command-pattern
 Hello world!
 [sgupta@rhel6x64 command]$ 
 */