State Design Pattern in C++ for a Music System

State Design pattern allows an object to change it's behavior based on its internal State.The Object will appear to change its class.
State Design Pattern in C++ to implement state machine of a Music Player System.
classes used:
MusicSystem -> is the current state context manager class.
State -> is the base class of all states classes.
OFFState -> is the concrete class derived from State.
ONState -> is the concrete class derived from State.
PAUSEDState ->is the concrete class derived from State.
Example:
#include<iostream>
using namespace std;

//current_context class
class State;
class MusicSystem
{
private:
    State *currentState;//to store current state.
   
public:
    enum statesEnum
        {
        ST_STOPPED,
        ST_PLAYING,
        ST_PAUSEDState
        };
public:
    MusicSystem();

    void stopMusic();
    void playMusic();
    void playNextTrack();
    void playPreviousTrack();
    void pauseMusic();
    void setCurrentContext(statesEnum state);
};

//abstract state class
class State
{
public:
    //MusicSystem's pointer is passed so that setCurrentState can be called.
    virtual void off(MusicSystem *ms){cout<<"Already Stopped."<<endl;}
    virtual void play(MusicSystem* ms){cout<<"Already Playing."<<endl;}
    virtual void playNextTrack(MusicSystem* ms){cout<<"Can not play Next in off/paused state."<<endl;}
    virtual void playPreviousTrack(MusicSystem* ms){cout<<"Can not play Previous in off/paused state."<<endl;}
    virtual void pause(MusicSystem* ms){cout<<"Can not Switch to pause in stopped state."<<endl;}
};
//concrete state class on
class OFFState:public State
{
public:
    void play(MusicSystem *ms);
};

//concrete state class off
class ONState:public State
{
public:
    void off(MusicSystem *ms);
    void playNextTrack(MusicSystem *ms);
    void playPreviousTrack(MusicSystem *ms);
    void pause(MusicSystem* ms);
};
//concrete class pause
class PAUSEDState:public State
{
public:
    void off(MusicSystem *ms);
    void playNextTrack(MusicSystem *ms);
    void playPreviousTrack(MusicSystem *ms);
    void play(MusicSystem* ms);
   
};

MusicSystem::MusicSystem()
{
    currentState=new OFFState;
}
void MusicSystem::stopMusic()
{
    currentState->off(this);  
}
void MusicSystem::playMusic()
{
    currentState->play(this);  
}
void MusicSystem::playNextTrack()
{
    currentState->playNextTrack(this);  
}
void MusicSystem::playPreviousTrack()
{
    currentState->playPreviousTrack(this);  
}
void MusicSystem::pauseMusic()
{
    currentState->pause(this);
}


    void OFFState::play(MusicSystem *ms)
    {
    cout<<"Turning to Play."<<endl;
    ms->setCurrentContext(MusicSystem::ST_PLAYING);
    delete this;
    }
    void ONState::off(MusicSystem *ms)
    {
    cout<<"Turning to Stopped."<<endl;
    ms->setCurrentContext(MusicSystem::ST_STOPPED);
    delete this;
    }
    void ONState::playNextTrack(MusicSystem *ms)
    {
    cout<<"Playing next track..."<<endl;
    }
    void ONState::playPreviousTrack(MusicSystem *ms)
    {
    cout<<"Playing previous track..."<<endl;
    }
    void ONState::pause(MusicSystem* ms)
    {
    cout<<"Switching to Pause."<<endl;   
    ms->setCurrentContext(MusicSystem::ST_PAUSEDState);
    }
   
    void PAUSEDState::off(MusicSystem *ms)
    {
    cout<<"Turning to Stopped."<<endl;
    ms->setCurrentContext(MusicSystem::ST_STOPPED);
    delete this;
    }
    void PAUSEDState::playNextTrack(MusicSystem *ms)
    {
    cout<<"Playing next track..."<<endl;
    }
    void PAUSEDState::playPreviousTrack(MusicSystem *ms)
    {
    cout<<"Playing previous track..."<<endl;
    }
    void PAUSEDState::play(MusicSystem* ms)
    {
    cout<<"Switching to Play."<<endl;   
    ms->setCurrentContext(MusicSystem::ST_PLAYING);
    }


void MusicSystem::setCurrentContext(statesEnum state)
    {
        if(state==ST_STOPPED)
    {
    currentState=new OFFState;
    }
    else if(state == ST_PLAYING)
    {
    currentState=new ONState();
    }
    else if(state == ST_PAUSEDState)
    {
    currentState=new PAUSEDState();
    }
    else
    {
    cout<<"Unknown state"<<endl;
    }
    }


//main
int main()
{
MusicSystem ms;

ms.MusicSystem::stopMusic();
ms.MusicSystem::stopMusic();
ms.MusicSystem::pauseMusic();
ms.MusicSystem::playNextTrack();
ms.MusicSystem::playPreviousTrack();

ms.MusicSystem::playMusic();
ms.MusicSystem::playMusic();
ms.MusicSystem::pauseMusic();
ms.MusicSystem::playNextTrack();
ms.MusicSystem::playPreviousTrack();

ms.MusicSystem::stopMusic();
ms.MusicSystem::playNextTrack();
ms.MusicSystem::playPreviousTrack();

return 0;
}
/*
Already Stopped.
Already Stopped.
Can not Switch to pause in stopped state.
Can not play Next in off/paused state.
Can not play Previous in off/paused state.
Turning to Play.
Already Playing.
Switching to Pause.
Playing next track...
Playing previous track...
Turning to Stopped.
Can not play Next in off/paused state.
Can not play Previous in off/paused state.
*/

Factory Method Design pattern in C++ and Abstract Factory Design pattern in CPP

"Factory Method Design pattern" is used when many derived classes are derived from a common base class and object of which derived class should be instantiated is only known at run time.
One way to achieve it by providing a static method in base class itself which returns pointer to the same base class.
When client needs to create object it calls this static method to create object of required derived class by passing type of subclass as string.And need not instantiate specific object by using subclass constructor.
Benefit of factory design pattern is that when new type is added then changes required only at one place where object is created ie only new case is added in factory method.
Intent of factory method is to provide a method to create objects, But defer the object creation to derive class based on some condition or configuration which acts like a virtual constructor. It decouples client from object creation.

Another variation of Factory pattern is "Abstract factory pattern".
In abstract factory design pattern an interface(Abstract base class) is provided to create object, But, let the subclass to decide which class to instantiate.
In example ShapeFactory is the abstract base class. And, object is created based on type passed.
Factory design pattern: We have factory that produces objects that from a particular base class.
Abstract Factory Design Pattern: We have factory that creates other factories and these factories in turn creates objects derived from other base class. Abstract factory needed when when we want to create collection of related objects and not just one object.

"Factory Method Design pattern" Implementation in C plus plus
#include<iostream>
using namespace std;

class Shape
{
public:
    virtual void whichShape()=0;
    static Shape* getShape(string s);//Factory method to create Object
};
class Rectangle:public Shape
{
public:
    void whichShape(){cout<<"Rectangle"<<endl;}
   
};
class Circle:public Shape
{
public:
    void whichShape(){cout<<"Circle"<<endl;}
   
};
Shape* Shape::getShape(string s)
{
if(s=="Rectangle")
    return new Rectangle();
if(s=="Circle")
    return new Circle();

}
int main()
{
//At run time requested type is Rectangle
Shape *s1= Shape::getShape("Rectangle");
s1->whichShape();
//At run time requested type is Circle
Shape *s2= Shape::getShape("Circle");
s2->whichShape();
return 0;
}
 //---------------------------
"Abstract Factory  Design pattern" Implementation in C++
#include<iostream>
using namespace std;

class Shape
{
public:
    virtual void whichShape()=0;
//    static Shape* getShape(string s);
};
class Rectangle:public Shape
{
public:
    void whichShape(){cout<<"Rectangle"<<endl;}
   
};
class Circle:public Shape
{
public:
    void whichShape(){cout<<"Circle"<<endl;}
   
};
class ShapeFactory
{
public:
    static Shape* getShape(string s);//Factory1
    static Shape* getEdgyShape(string s);//Factory2
    static Shape* getRoundedShape(string s);//Factory3
};
Shape* ShapeFactory::getShape(string s)
{
if(s=="Rectangle")
    return new Rectangle();
if(s=="Circle")
    return new Circle();

}
int main()
{
//At run time requested type is Rectangle
ShapeFactory* sf = new ShapeFactory();
Shape* s1 = sf->getShape("Rectangle");
s1->whichShape();
//At run time requested type is Circle
ShapeFactory* sf2 = new ShapeFactory();
Shape* s2 = sf2->getShape("Circle");
s2->whichShape();

return 0;
}
 

State Design Pattern code in C++

State Design Pattern to design a Music System in C++ language.
#include<iostream>
using namespace std;

//current_context class
class State;
class MusicSystem
{
private:
    State *currentState;
public:
    MusicSystem();

    void stopMusic();
    void playMusic();
    void playNextTrack();
    void playPreviousTrack();
    void setCurrentContext(State* s)
    {
    currentState=s;
    }
};

//abstract state class

class State
{
public:
    virtual void offState(MusicSystem *ms){cout<<"Already Stopped"<<endl;}
    virtual void onState(MusicSystem* ms){cout<<"Already Playing"<<endl;}
    virtual void playNextTrack(MusicSystem* ms){cout<<"Can not play Next in off state."<<endl;}
    virtual void playPreviousTrack(MusicSystem* ms){cout<<"Can not play Previous in off state."<<endl;}
};
//concrete state class on
class OFF:public State
{
public:
    void onState(MusicSystem *ms);
};

//concrete state class off
class ON:public State
{
public:
    void offState(MusicSystem *ms);
    void playNextTrack(MusicSystem *ms);
    void playPreviousTrack(MusicSystem *ms);
};

MusicSystem::MusicSystem()
{
    currentState=new OFF;
}
void MusicSystem::stopMusic()
{
    currentState->offState(this);   
}
void MusicSystem::playMusic()
{
    currentState->onState(this);   
}
void MusicSystem::playNextTrack()
{
    currentState->playNextTrack(this);   
}
void MusicSystem::playPreviousTrack()
{
    currentState->playPreviousTrack(this);   
}


    void OFF::onState(MusicSystem *ms)
    {
    cout<<"Turning from stopped to Play."<<endl;
    ms->setCurrentContext(new ON());
    delete this;
    }
    void ON::offState(MusicSystem *ms)
    {
    cout<<"Turning from Playing to Stopped."<<endl;
    ms->setCurrentContext(new OFF());
    delete this;
    }
    void ON::playNextTrack(MusicSystem *ms)
    {
    cout<<"Playing next track..."<<endl;
    //ms->setCurrentContext(new OFF());
    //delete this;
    }
    void ON::playPreviousTrack(MusicSystem *ms)
    {
    cout<<"Playing previous track..."<<endl;
    //ms->setCurrentContext(new OFF());
    //delete this;
    }


//main
int main()
{
MusicSystem ms;

ms.MusicSystem::stopMusic();
ms.MusicSystem::stopMusic();
ms.MusicSystem::stopMusic();
ms.MusicSystem::playNextTrack();
ms.MusicSystem::playPreviousTrack();

ms.MusicSystem::playMusic();
ms.MusicSystem::playMusic();
ms.MusicSystem::playMusic();
ms.MusicSystem::playNextTrack();
ms.MusicSystem::playPreviousTrack();

ms.MusicSystem::stopMusic();
ms.MusicSystem::playNextTrack();
ms.MusicSystem::playPreviousTrack();

return 0;
}

Message queue IPC example in C

//message queue server
#include<stdio.h>
#include<unistd.h>
#include<fcntl.h>
#include<sys/types.h>
#include<sys/ipc.h>
#include<sys/msg.h>
#include<sys/stat.h>
#include<string.h>
#define KEY 500
struct msg
{
 long int msgtype;
 char msgfromclient[1024];
 int pid;
}msgbuf;

int main()
{
 int mqid,n,fd,m1;
 mqid=msgget(KEY,0666|IPC_CREAT);
 while(1)
 {
 msgrcv(mqid,&msgbuf,sizeof(msgbuf),1,0);
 printf("Filename from client %s\n",msgbuf.msgfromclient);

//sending requested file data to client
 fd=open(msgbuf.msgfromclient,O_RDONLY);
 n=read(fd,msgbuf.msgfromclient,1024);
 msgbuf.msgtype=msgbuf.pid;
 msgbuf.pid=getpid();
 msgsnd(mqid,&msgbuf,sizeof(msgbuf),0);
 }
return 0;
}
//client
#include<stdio.h>
#include<unistd.h>
#include<fcntl.h>
#include<sys/types.h>
#include<sys/stat.h>
#include<string.h>
#define KEY 500

struct msg
{
 long int type;
 char a[1024];
 int pid;
}p,p1;
int main()
{
 int m;
 m=msgget(KEY,0);
//fill the structure to send data
 p.type=1;
 printf("\nEnter the msg");
 scanf("%s",&p.a);
 pid_t pid;
 p.pid=getpid();
 msgsnd(m,&p,sizeof(p),0);
 msgrcv(m,&p1,sizeof(p),p.pid,0);
 printf("%s",p1.a);
return 0;
}

//output:
ServerTerminal$ ./server
ClientTerminal$ ./client
Enter the msg hello.txt

ServerTerminal$ 
Filename from client hello
ClientTerminal$ ./client
contents of hello.txt

Synchronized shared memory server and client in C

Client writes  a text in shared memory.
Then server reads that and convert to upper case and write back to shared memory.
Client reads toggled text from shared memory.
//Server
#include<stdio.h>
#include<sys/types.h>
#include<sys/ipc.h>
#include<sys/sem.h>
#include<sys/shm.h>

#define MY_KEY 1983
#define SHM_SIZE 0x1000

void toggleCase(char* buff, int cnt);

int main()
{
int semId, shmId;
char* pShm;
struct sembuf smop;

semId=semget(MY_KEY,2,0660 | IPC_CREAT);

semctl(semId,0,SETVAL,0);
semctl(semId,1,SETVAL,0);
shmId = shmget(MY_KEY, SHM_SIZE, 0660 | IPC_CREAT);

pShm=shmat(shmId,NULL,0);

while(1)
{
smop.sem_num = 0;
smop.sem_op = -1;
smop.sem_flg = 0;
semop(semId,&smop,1);

strcpy(pShm+256,pShm);
toggleCase(pShm+256, strlen(pShm+256));

smop.sem_num = 1;
smop.sem_op = 1;
smop.sem_flg = 0;
semop(semId,&smop,1);

}
return 0;
}

void toggleCase(char* buff, int cnt)
{
printf("\ntoggle\n");
int ii;
for(ii=0;ii<cnt;ii++)
{
if((buff[ii]>='A')&&(buff[ii]<='Z'))
buff[ii]+=0x20;
else if((buff[ii]>='a')&&(buff[ii]<='z'))
buff[ii]-=0x20;
}
}
//Client
#include<stdio.h>
#include<sys/types.h>
#include<sys/ipc.h>
#include<sys/sem.h>
#include<sys/shm.h>

#define MY_KEY 1983
#define SHM_SIZE 0x1000

#define MSG_LEN 256
#define RESP_MSG_START 256

//void toggleCase(char* buff, int cnt);

int main()
{
int semId, shmId;
char* pShm;
struct sembuf smop;

semId=semget(MY_KEY,2,0);

//semctl(semId,0,SETVAL,0);
//semctl(semId,1,SETVAL,0);

shmId = shmget(MY_KEY, SHM_SIZE,0);

pShm=shmat(shmId,NULL,0);

fgets(pShm,MSG_LEN,stdin);

smop.sem_num = 0;
smop.sem_op = 1;
smop.sem_flg = 0;
semop(semId,&smop,1);

smop.sem_num = 1;
smop.sem_op = -1;
smop.sem_flg = 0;
semop(semId,&smop,1);
puts(pShm+RESP_MSG_START);
return 0;
}

//void toggleCase(char* buff, int cnt)
//{
//printf("\ntoggle\n");
//}
//terminal 1: ./server
//terminal 2: ./client
india
check
//terminal 1: 
//terminal 2:
INDIA  

Does friend function follows access specifier rule in C++

No, friend functions do not follow access specifier rules as they are not members function. Friend function declared in any access specfier can access private data of the class using object.
#include<iostream>
using namespace std;
class sample
{
private:
        int a;
private:
        void privateNormalFunction(){};
private:
        friend void f1(sample);
protected:
        void friend f2(sample);
public:
        friend void f3(sample);
};
void f1(sample s)
{
s.a=10;
cout<<"f1::a"<<s.a<<endl;
}
void f2(sample s)
{
s.a=10;
cout<<"f2::a"<<s.a<<endl;
}
void f3(sample s)
{
s.a=10;
cout<<"f3::a"<<s.a<<endl;
}
int main()
{
sample s;
f1(s);
f2(s);
f3(s);
return 0;
}                                                                                                                                               
                                                                                                                                                

Private virtual function

//Can virtual function be private?
//Suppose virtual function vf() is declared as private in base.Even though vf is overriden as public in derived compiler will throw error of private at run time. But one work around could be given to declare a virtual function as private by making main() as friend function of that class.Because friend functions can access the private members.
#include<iostream>
using namespace std;
class base
{
private:
        virtual void vf(){cout<<"base::vf"<<endl;}
//friend int main();
};
class derived:public base
{
public:
void vf(){cout<<"derved::vf;"<<endl;}
};
int main()
{
base* bp = new derived;
bp->vf();//error: ‘virtual void base::vf()’ is private

return 0;
}