C++

Monday, May 5, 2014

Memento Pattern

/*
Without violating encapsulation, capture and externalize an object's internal state
so that the object can be restored to this state later.
*/

1 #include<iostream>
2
3 using namespace std;
4
5 class EmployeeDataMemento{
6 public:
7 int id;
8 string name;
9 EmployeeDataMemento(){}
10 EmployeeDataMemento(int number, string employee_name)
11 {
12 id = number;
13 name = employee_name;
14 }
15 };
16
17 class EmployeeData{
18 int id;
19 string name;
20 EmployeeDataMemento *ed;
21 public:
22 EmployeeData(int number, string emp_name)
23 {
24 id = number;
25 name = emp_name;
26 ed = new EmployeeDataMemento(id,name);
27 }
28 void displayEmployeeData()
29 {
30 cout<<"Emp Id: "<<id<<endl;
31 cout<<"employee Name: "<<name<<endl;
32 }
33 void update(int number, string emp_name)
34 {
35 id = number;
36 name = emp_name;
37 }

38 void undo(char ans)

39 {

40 if(ans == 'Y' || ans == 'y')

41 {

42 id = ed->id;

43 name = ed->name;

44 }

45 else

46 ed = new EmployeeDataMemento(id,name);

47 }

48 };

51 int main()

52 {

53 EmployeeData ed(100, "Dhananjay Kumar");

54 ed.displayEmployeeData();

55 int id;

56 string name;

57 cout<<"Enter New Id = ";

58 cin>>id;

59 cout<<"Enter New Name = ";

60 cin>>name;

61 cout<<"Update the data.."<<endl;

62 ed.update(id, name);

63 ed.displayEmployeeData();

64 cout<<"Wants to Undo updates..? Y/N: ";

65 char ans;

66 cin>>ans;

67 ed.undo(ans);

68 ed.displayEmployeeData();

69 }

Observer Pattern

1 #include<iostream>
2 #include<vector>
3 using namespace std;
4
5 class Notification{
6 public:
7 virtual void Notify()=0;
8 };
9
10 class EmailNotification: public Notification{
11 public:
12 void Notify(){cout<<"Email Notification sent to.....@yahoo.com"<<endl;}
13 };
14
15 class SMSNotification: public Notification{
16 public:
17 void Notify(){cout<<"SMS Notification sent to.... 999999990 "<<endl;}
18
19 };
20
21 class Notifier{
22 vector<Notification *> notifications;
23 public:
24 void addNotifications(Notification *notification)
25 {
26 notifications.push_back(notification);
27 }
28 void NotifyAll()
29 {
30 for(int i = 0; i < notifications.size(); i++)
31 notifications[i]->Notify();
32 }
33 };

35 int main()

36 {

37 cout<<"Do you want to send notifications....? Y/N: ";

38 Notifier *notify = new Notifier();

39 char response;

40 cin>> response;

42 if(response == 'Y' || response == 'y')

43 {

44 EmailNotification *emailnotification = new EmailNotification();

45 SMSNotification *smsnotification = new SMSNotification();

46 notify->addNotifications(smsnotification);

47 notify->addNotifications(emailnotification);

48 notify->NotifyAll();

49 }

50 else

51 {

52 cout<<"No Notification Sent. Bye!!"<<endl;

53 }

54 }

Sunday, May 4, 2014

Builder Design Pattern

/*
Builder pattern helps us to separate the construction of a complex object from its representation so that the same construction process can create different representations.
*/

1 #include <iostream>
2 using namespace std;
3
4 class Report{
5 char *type;
6 char *header;
7 char *footer;
8 public:
9
10 void set_type(char *report_type)
11 {
12 type = report_type;
13 }
14 void set_header(char *header_text)
15 {
16 header = header_text;
17 }
18 void set_footer(char *footer_text)
19 {
20 footer = footer_text;
21 }
22 void display_report()
23 {
24 cout<<"========================================="<<endl;
25 cout<<"Type = "<<type<<endl;
26 cout<<"Header = "<<header<<endl;
27 cout<<"Footer = "<<footer<<endl;
28 }
29 };
30
31 class ReportBuilder{
32 protected:
33 Report *report;
34 public:
35 virtual void set_type() = 0;
36 virtual void set_header() = 0;
37 virtual void set_footer() = 0;
38 virtual void create_report() { report = new Report(); }
39 virtual Report* get_report(){return report;}
40 virtual ~ReportBuilder() {delete report;}
41 };

43 class PDFReportBuilder: public ReportBuilder{

44 public:

45 virtual void set_type() { report->set_type("PDF"); }

46 virtual void set_header(){report->set_header("Dhananjay PDF Ltd.");}

47 virtual void set_footer(){report->set_footer("Thanks for this PDF file.");}

49 };

51 class XLSReportBuilder: public ReportBuilder{

52 public:

53 virtual void set_type() { report->set_type("Excel"); }

54 virtual void set_header(){report->set_header("Dhananjay Excel Ltd.");}

55 virtual void set_footer(){report->set_footer("Thanks for this XLS file.");}

56 };

58 class ReportDirector{

59 public:

60 Report* make_report(ReportBuilder *rb)

61 {

62 rb->create_report();

63 rb->set_type();

64 rb->set_header();

65 rb->set_footer();

66 return rb->get_report();

67 }

68 };

71 int main()

72 {

73 Report *report;

74 ReportDirector *rd = new ReportDirector();

75 PDFReportBuilder *prb = new PDFReportBuilder();

76 report = rd->make_report(prb);

77 report->display_report();

79 XLSReportBuilder *xrb = new XLSReportBuilder();

80 report = rd->make_report(xrb);

81 report->display_report();

83 }

Saturday, May 3, 2014

Abstract Factory Pattern

1 #include <iostream>
2
3 using namespace std;
4
5 class Mobile{
6 public:
7 virtual void getName() { }
8 virtual void getScreen() { }
9 virtual void getBattery() { }
10 };
11
12 class NokiaMobile: public Mobile{
13 public:
14 virtual void getName()
15 {
16 cout<<"This is Nokia Mobile.."<<endl;
17 }
18 virtual void getScreen()
19 {
20 cout<<"This is Nokia Mobile screen.."<<endl;
21 }
22 virtual void getBattery()
23 {
24 cout<<"This is Nokia Mobile battery.."<<endl;
25 }
26 };
27
28
29 class SamsungMobile: public Mobile{
30 public:
31 void display()
32 {
33 cout<<"This is Samsung Mobile.."<<endl;
34 }
35 virtual void getScreen()
36 {
37 cout<<"This is Samsung Mobile screen.."<<endl;
38 }
39 virtual void getBattery()
40 {
41 cout<<"This is Samsung Mobile battery.."<<endl;
42 }
43 };

45 class Charger{

46 public:

47 virtual void getName(){}

49 };

50 class NokiaCharger: public Charger{

51 public:

52 virtual void getName()

53 {

54 cerr<<"This is Nokia Charger.."<<endl;

55 }

57 };

59 class SamsungCharger: public Charger{

60 public:

61 virtual void getName()

62 {

63 cerr<<"This is Samsung Charger.."<<endl;

64 }

66 };

69 class MobileFactory{

70 public:

71 virtual Mobile* getMobile(){}

72 virtual Charger* getCharger(){}

73 };

75 class NokiaMobileFactory: public MobileFactory{

76 public:

77 virtual Mobile* getMobile()

78 {

79 return new NokiaMobile();

80 }

81 virtual Charger* getCharger()

82 {

83 return new NokiaCharger();

84 }

85 };

88 class SamsungMobileFactory : public MobileFactory{

89 public:

90 virtual Mobile* getMobile()

91 {

92 return new SamsungMobile();

93 }

94 virtual Charger* getCharger()

95 {

96 return new SamsungCharger();

97 }

98 };

100

101 class FactoryCreator{

102 public:

103 MobileFactory* createFactory(int order)

104 {

105 if(order == 1)

106 return new NokiaMobileFactory();

107 else

108 return new SamsungMobileFactory();

109 }

110 };

111

112

113 int main()

114 {

115 int orderMobile;

116 cout<<"1. Nokia "<<endl;

117 cout<<"2. Samsung "<<endl;

118 cin>>orderMobile;

119 FactoryCreator *fc = new FactoryCreator();

120 fc->createFactory(orderMobile)->getMobile()->getName();

121 fc->createFactory(orderMobile)->getMobile()->getScreen();

122 fc->createFactory(orderMobile)->getMobile()->getBattery();

123 fc->createFactory(orderMobile)->getCharger()->getName();

124 delete fc;

125

126 }

Command Design Pattern

// Implementing Command Design pattern. This is behavioral pattern which allows
// to encapsulate request as an object.

#include <iostream>

using namespace std;

class FileCommand{
public:
virtual void execute(){}
};

class FileOpen : public FileCommand{
public:
void execute()
{
cout<<"File Opened.."<<endl;
}
};

class FileClose : public FileCommand{
public:
void execute()
{
cout<<"File Closed.."<<endl;
}

};

//Invoker Class

class FileCommandInvoker{

FileCommand* array[2];

public:

FileCommandInvoker()

{

array[0] = new FileOpen();

array[1] = new FileClose();

}

FileCommand* getCommand(int command)

{

FileCommand *fc = 0;

if(command == 1)

fc = array[0];

else if(command == 2)

fc = array[1];

return fc;

}

};

//Client Code

int main()

{

int command;

cout<<"1. File Open "<<endl;

cout<<"2. File Close "<<endl;

cout<<"Enter 1-2 : "<<endl;

cin>>command;

FileCommandInvoker *fci = new FileCommandInvoker();

FileCommand *fc = fci->getCommand(command);

fc->execute();

return 0;

}

Tuesday, January 22, 2013

Base Class Pointer

#include<iostream>
using namespace std;

class A{
public:
virtual void f1()
{
cout<< "in A:: f1()"<<endl;
}
};

class B : public A{
public:
void f1()
{
cout<<"in B: f1()"<<endl;
}
virtual void f2()
{
cout<<"in B: f2()"<<endl;
}

};

int main()
{

A *pa = new B;
pa->f1();
pa->f2(); // Compile error as f2() is not known to base class

}

Char Pointer : Segmentation Fault

#include<iostream>
using namespace std;
int main()
{
//value will be in read only area of data segment
char *str = "abc";
cout<<"Str = "<<str<<endl;
str[1] = 'x';// This will give segmentation fault
cout<<"Str = "<<str<<endl;
}

PS: char str[] = "abc"; will be in stack hence can be modified.

Wednesday, July 18, 2012

Fibonacci Series

/*
Fibonacci Series: 0 1 1 2 3 5 8....
*/
/*
Imp Test: N is a Fibonacci number if and only if 5 N^2 + 4 or 5N^2 – 4 is a square number.
*/

#include <iostream>
using namespace std;

void fib(int n)
{
int prev=0;
int curr = 1;
int next;
for (int i=0;i<n;i++)
{
if(i<=1)
next = i;
else
{
next = prev+curr;
prev = curr;
curr= next;
}
cout<<next<<"\t";
}
}

int main()
{
int n;
cout<<"How many fib ? ";
cin>>n;
fib(n);
return 0;
}
//shorter version of Fibonacci series
void fib(int n)
{
int a,b,c,i;
for(a=0,b=1,c=0,i=0;i<n;c=a+b,a=b,b=c,i++) cout<<c<<"\t";
}

Saturday, April 16, 2011

C++: Operator Overloading

#include<iostream>

using namespace std;

class A
{
        int a;
        public:
                A(int x=0):a(x){
                        cout<<"in Cons"<<endl;
                }
                friend A operator+(const A& _a1, const A& _a2);
                friend ostream& operator<<(ostream &out, const A& _a);
                int getData()
                {
                        return a;

                }
};

A operator+(const A& _a1, const A& _a2)
{
        cout<<"Inside operator+"<<endl;

        return A(_a1.a + _a2.a);

}
ostream& operator<<(ostream & o, const A& _a)
{
        o << _a.a;
        return o;

}

int main()
{
        A x1(2), x2(3);
        A x3 = x1 + x2;
        cout << x3 <<", "<<x1<<endl;

}

Wednesday, April 13, 2011

C++: Deep Copy

#include<iostream>
using namespace std;

class MyStr
{
        char *str;
        public:

        // Constructor
        MyStr(char *_s="")
        {
                if(_s)
                {
                        str = new char[strlen(_s)];
                        strcpy(str,_s);
                }

        }
        //Copy COnstructor
        MyStr(const MyStr & _rhs)
        {
                str = new char[strlen(_rhs.str)];
                strcpy(str,_rhs.str);
        }
        //Assignment Operator
        MyStr& operator=(const MyStr& _rhs)
        {
                //Check for self-assignment
                if(this == &_rhs)
                        return *this;
                // Deallocate memory if it is holding.
                delete [] str;
                //Allocate memory and copy the content
                if(_rhs.str)
                {
                        str = new char[strlen(_rhs.str)];
                        strcpy(str,_rhs.str);
                }
                else
                        str = 0;

                return *this;
        }
        //Destructor
        ~MyStr()
        {
                delete[] str;
                str=0;
        }
        char * getStr()
        {
                return str;

        }

};

int main()
{
        using namespace std;
        MyStr s("Dhananjay Kuamr"),s3;
        {
        s= s;
        }
        cout<<"THe out of s is after =:- "<<s.getStr() <<endl;
        s3 = s;
        cout<<"THe out of s3 is after =:- "<<s3.getStr() <<endl;

}