Simplest builder pattern code sample in C++ for job interview questions using an abstract base class with derived concrete classes.
This example builds ‘distributed work packages’
This seems to the best build pattern code on the net. This basically builds an object step by step. In a nutshell, this example, distributed work packages are abstracted to be persistant and platform independent. This includes files, queues, pathway, etc. A reader or parser retrieves the archives specs through DistrWorkPackage. It will then delegate each build step to the builder object that was registered by the client. At the end, the client will retrieve the end result from the builder
//from http://sourcemaking.com/design_patterns/builder/cpp/1#
#include
#include
#include
enum PersistenceType
{
File, Queue, Pathway
};
struct PersistenceAttribute
{
PersistenceType type;
char value[30];
};
class DistrWorkPackage
{
public:
DistrWorkPackage(char *type)
{
sprintf(_desc, “Distributed Work Package for: %s”, type);
}
void setFile(char *f, char *v)
{
sprintf(_temp, “\n File(%s): %s”, f, v);
strcat(_desc, _temp);
}
void setQueue(char *q, char *v)
{
sprintf(_temp, “\n Queue(%s): %s”, q, v);
strcat(_desc, _temp);
}
void setPathway(char *p, char *v)
{
sprintf(_temp, “\n Pathway(%s): %s”, p, v);
strcat(_desc, _temp);
}
const char *getState()
{
return _desc;
}
private:
char _desc[200], _temp[80];
};
class Builder
{
public:
virtual void configureFile(char*) = 0;
virtual void configureQueue(char*) = 0;
virtual void configurePathway(char*) = 0;
DistrWorkPackage *getResult()
{
return _result;
}
protected:
DistrWorkPackage *_result;
};
class UnixBuilder: public Builder
{
public:
UnixBuilder()
{
_result = new DistrWorkPackage(“Unix”);
}
void configureFile(char *name)
{
_result->setFile(“flatFile”, name);
}
void configureQueue(char *queue)
{
_result->setQueue(“FIFO”, queue);
}
void configurePathway(char *type)
{
_result->setPathway(“thread”, type);
}
};
class VmsBuilder: public Builder
{
public:
VmsBuilder()
{
_result = new DistrWorkPackage(“Vms”);
}
void configureFile(char *name)
{
_result->setFile(“ISAM”, name);
}
void configureQueue(char *queue)
{
_result->setQueue(“priority”, queue);
}
void configurePathway(char *type)
{
_result->setPathway(“LWP”, type);
}
};
class Reader
{
public:
void setBuilder(Builder *b)
{
_builder = b;
}
void construct(PersistenceAttribute[], int);
private:
Builder *_builder;
};
void Reader::construct(PersistenceAttribute list[], int num)
{
for (int i = 0; i < num; i++)
if (list[i].type == File)
_builder->configureFile(list[i].value);
else if (list[i].type == Queue)
_builder->configureQueue(list[i].value);
else if (list[i].type == Pathway)
_builder->configurePathway(list[i].value);
}
const int NUM_ENTRIES = 6;
PersistenceAttribute input[NUM_ENTRIES] =
{
{
File, “state.dat”
}
,
{
File, “config.sys”
}
,
{
Queue, “compute”
}
,
{
Queue, “log”
}
,
{
Pathway, “authentication”
}
,
{
Pathway, “error processing”
}
};
int main()
{
UnixBuilder unixBuilder;
VmsBuilder vmsBuilder;
Reader reader;
reader.setBuilder(&unixBuilder);
reader.construct(input, NUM_ENTRIES);
cout << unixBuilder.getResult()->getState() << endl;
reader.setBuilder(&vmsBuilder);
reader.construct(input, NUM_ENTRIES);
cout << vmsBuilder.getResult()->getState() << endl;
}
This will output:
Distributed Work Package for: Unix
File(flatFile): state.dat
File(flatFile): config.sys
Queue(FIFO): compute
Queue(FIFO): log
Pathway(thread): authentication
Pathway(thread): error processing
Distributed Work Package for: Vms
File(ISAM): state.dat
File(ISAM): config.sys
Queue(priority): compute
Queue(priority): log
Pathway(LWP): authentication
Pathway(LWP): error processing
