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

HOW DO YOU START A PROFITABLE TRADING BUSINESS? Read more NOW >>>

NOTE I now post my TRADING ALERTS into my personal FACEBOOK ACCOUNT and TWITTER. Don't worry as I don't post stupid cat videos or what I eat!