Skip to main content

8 posts tagged with "Design Patterns"

View All Tags

Design Patterns and there advantages

· One min read

What are Design Patterns​

Design patterns are solutions/patterns to problems which occurs in many situations.

'd'

Advantages of Design Patterns​

  1. Developers can select a tried and well tested solutions
  2. Makes development and maintenance of code easy and fast
  3. Design patterns are language independent hence we use them in any language which supports object oriented
  4. Highly flexible and can be used in any application/domain
  5. Using design patterns we can create reusable object oriented designs

'Factory Method' Design Pattern using simple program

· One min read

Definition:

Creates an instance of several derived classes. or Define an interface for creating an object, but let subclasses decide which class to instantiate. Factory Method lets a class defer instantiation to subclasses.

Program:

#include "iostream"
using namespace std;

class Product
{
public:
    virtual void Show() = 0;
};

class ConcreteProductA : public Product
{
public:
    virtual void Show()
    {
      cout<<"ConcreteProductA"<<endl;
    }
};

class ConcreteProductB : public Product
{
public:
    virtual void Show()
    {
      cout<<"ConcreteProductB"<<endl;
    }
};

class Creator
{
public:
    virtual Product* FactoryMethod() = 0;
};

class ConcreteCreatorA : public Creator
{
public:
    ConcreteCreatorA() {}
    virtual Product* FactoryMethod()
    {
      return new ConcreteProductA();
    }
};

class ConcreteCreatorB : public Creator
{
public:
    virtual Product* FactoryMethod()
    {
      return new ConcreteProductB();
    }
};

void main()
{
  Creator* creators[2];

  creators[0] =  new ConcreteCreatorA();
  creators[1] =  new ConcreteCreatorB();

  for (int i=0; i < 2; i++)    {     Product* product = creators[i]->FactoryMethod();
    cout<<"Created "<<Show();
  }

  getchar();
}

/*
OUT PUT
-------
Created
ConcreteProductA
Created
ConcreteProductB
*/

'Singleton' Design Pattern using simple program

· One min read

Definition: Ensure a class only has one instance and provide a global point of access to it.

Program:

#include "iostream"
using namespace std;

class Singleton
{
private:
    static Singleton* instance;
    Singleton() {}

public:
    static Singleton* Instance()
    {
        if(instance == NULL)
        {
            instance = new Singleton();
        }
        return instance;
    }

    void Show()
    {
        cout&lt;&lt;"Singleton Class"&lt;&lt;endl;
    }
};

Singleton* Singleton::instance = NULL;

int main()
{
    Singleton* obj1 = Singleton::Instance();
    obj1->Show();

    Singleton* obj2 = Singleton::Instance();
    obj2->Show();

    getchar();

    return 0;
}

/*
OUT PUT
-------
Singleton Class
Singleton Class
*/

‘AbstractFactory’ Design Pattern using simple program

· 2 min read

Definition: Provide an interface for creating families of related or dependent objects without specifying their concrete classes.

Program:


#include "iostream"
using namespace std;

// Abstract Factory pattern
class AbstractProductA
{
public:
  virtual void Show() = 0;
};

class AbstractProductB
{
public:
  virtual void Show() = 0;
};

class AbstractFactory
{
public:
 virtual AbstractProductA* CreateProductA() = 0;
 virtual AbstractProductB* CreateProductB() = 0;
};

class ProductA1 : public AbstractProductA
{
public:
  virtual void Show()
  {
    cout<<"ProductA1 Show"<<endl;>
  }
};

class ProductB1 : public AbstractProductB
{
public:
  virtual void Show()
  {
    cout<<"ProductB1 Show"<<endl;>
  }
};

class ProductA2 : public AbstractProductA
{
public:
  virtual void Show()
  {
    cout<<"ProductA2 Show"<<endl;
  }
};

class ProductB2 : public AbstractProductB
{
public:
  virtual void Show()
  {
    cout<<"ProductB2 Show"<<endl;
  }
};

class ConcreteFactory1 : public AbstractFactory
{
public:
    virtual AbstractProductA* CreateProductA()
    {
      return new ProductA1();
    }

    virtual AbstractProductB* CreateProductB()
    {
      return new ProductB1();
    }
};

class ConcreteFactory2 : public AbstractFactory
{
public:
    virtual AbstractProductA* CreateProductA()
    {
      return new ProductA2();
    }

    virtual AbstractProductB* CreateProductB()
    {
      return new ProductB2();
    }
};

class Client
{
private:
  AbstractProductA* _abstractProductA;
  AbstractProductB* _abstractProductB;

public:
    Client(AbstractFactory\* factory)
    {
      _abstractProductB = factory->CreateProductB();
      _abstractProductA = factory->CreateProductA();
    }

    void Run()
    {
      _abstractProductA->Show();
      _abstractProductB->Show();

      delete _abstractProductA;
      delete _abstractProductB;
    }
};

void main()
{
  // Abstract factory #1
  AbstractFactory* factory1 = new ConcreteFactory1();
  Client* client1 = new Client(factory1);
  client1->Run();

  delete factory1;
  delete client1;

  // Abstract factory #2
  AbstractFactory* factory2 = new ConcreteFactory2();
  Client* client2 = new Client(factory2);
  client2->Run();

  delete factory2;
  delete client2;

  getchar();
}

/*
OUT PUT
-------
\[ProductA1\] Show
\[ProductB1\] Show
\[ProductA2\] Show
\[ProductB2\] Show
\*/

'Builder' Design Pattern using simple program

· One min read

Definition:

Separate the construction of a complex object from its representation so that the same construction process can create different representations.

Program:

#include "iostream"
using namespace std;

// Builder pattern -- Creational example
class Product
{
private:
    char* _parts[10];
    int i;

public:
    Product()
    {
      i = 0;
    }

    void Add(char* part)
    {
      _parts[i] = part;
      i++;
    }

    void Show()
    {
        cout<
      for(int j = 0; j    {
         cout<<_parts[j]<BuildPartA();
      builder->BuildPartB();
    }
};

class ConcreteBuilder1 : public Builder
{
    private:
      Product _product;

    public:
    virtual void BuildPartA()
    {
      _product.Add("PartA");
    }

    virtual void BuildPartB()
    {
      _product.Add("PartB");
    }

    virtual Product GetResult()
    {
      return _product;
    }
};

class ConcreteBuilder2 : public Builder
{
    private:
      Product _product;

    public:
    virtual void BuildPartA()
    {
      _product.Add("PartX");
    }

    virtual void BuildPartB()
    {
      _product.Add("PartY");
    }

    virtual Product GetResult()
    {
      return _product;
    }
};

void main()
{
  // Create director and builders
  Director director;

  ConcreteBuilder1 b1;
  ConcreteBuilder2 b2;

  Product p1;
  Product p2;

  // Construct product p1
  director.Construct(&amp;b1);
  p1 = b1.GetResult();
  p1.Show();

  // Construct product p2
  director.Construct(&amp;b2);
  p2 = b2.GetResult();
  p2.Show();

  getchar();
}

/*
OUT PUT

Product Parts:
PartA
PartB

Product Parts:
PartX
PartY
*/

All About Design Patterns

· One min read

Definition​

Design Patterns represent solutions to problems that arise when developing software within a particular context. Patterns help you learn from other's successes, instead of your own failures. Mark Johnson (cited by Bruce Eckel)

Types of Design Patterns​

There are three types of design patterns

  1. Creational Patterns: Creational Patterns deals with initializing and configuring classes and objects
  2. Structural Patterns: Structural Patterns deals with decoupling the interface and implementation of classes and objects
  3. Behavioral Patterns: Behavioral Patterns deals with dynamic interactions among societies of classes and objects

These three design patters are divided in to 22 different kinds of patterns as shown below.

Design Pattern: C# Singleton

· One min read
using System;

namespace CSharp { 
  //Singleton: Ensure a class only has one instance, 
  //and provide a global point of access to it. 
  class Singleton { 
    //Member Variable 
    private static Singleton instance = null;
    
    //Memeber Functions
    private Singleton()
    {
    }

    public static Singleton Instance()
    {
        if(instance == null )
        {
          instance = new Singleton ();
        }

        return instance;
    }

    public void print()
    {
      Console.WriteLine("Singleton Class" );
    }

};

class Program { 

  static void Main(string[] args) {
     Singleton n = Singleton .Instance(); 
     n.print();
     Singleton p = Singleton .Instance();
     p.print();
  }

 } 

}