Thinking In C++. Volume 2: Practical Programming

  enum BPart {FRAME, WHEEL, SEAT, DERAILLEUR,

    HANDLEBAR, SPROCKET, RACK, SHOCK, NPARTS};

  BicyclePart(BPart);

  friend std::ostream&

  operator<<(std::ostream&, const BicyclePart&);

private:

  BPart id;

  static std::string names[NPARTS];

};

class Bicycle {

public:

  ~Bicycle();

  void addPart(BicyclePart*);

  friend std::ostream&

  operator<<(std::ostream&, const Bicycle&);

private:

  std::vector parts;

};

class BicycleBuilder {

public:

  BicycleBuilder() {

    product = 0;

  }

  void createProduct() {

    product = new Bicycle;

  }

  virtual void buildFrame() = 0;

  virtual void buildWheel() = 0;

  virtual void buildSeat() = 0;

  virtual void buildDerailleur() = 0;

  virtual void buildHandlebar() = 0;

  virtual void buildSprocket() = 0;

  virtual void buildRack() = 0;

  virtual void buildShock() = 0;

  virtual std::string getBikeName() const = 0;

  Bicycle* getProduct() {

    Bicycle* temp = product;

    product = 0;  // relinquish product

    return temp;

  }

protected:

  Bicycle* product;

};

class MountainBikeBuilder : public BicycleBuilder {

public:

  void buildFrame();

  void buildWheel();

  void buildSeat();

  void buildDerailleur();

  void buildHandlebar();

  void buildSprocket();

  void buildRack();

  void buildShock();

  std::string getBikeName() const {

    return "MountainBike";

  }

};

class TouringBikeBuilder : public BicycleBuilder {

public:

  void buildFrame();

  void buildWheel();

  void buildSeat();

  void buildDerailleur();

  void buildHandlebar();

  void buildSprocket();

  void buildRack();

  void buildShock();

  std::string getBikeName() const {

    return "TouringBike";

  }

};

class RacingBikeBuilder : public BicycleBuilder {

public:

  void buildFrame();

  void buildWheel();

  void buildSeat();

  void buildDerailleur();

  void buildHandlebar();

  void buildSprocket();

  void buildRack();

  void buildShock();

  std::string getBikeName() const {

    return "RacingBike";

  }

};

class BicycleTechnician {

public:

  BicycleTechnician() {

    builder = 0;

  }

  void setBuilder(BicycleBuilder* b) {

    builder = b;

  }

  void construct();

private:

  BicycleBuilder* builder;

};

#endif ///:~

A Bicycle holds a vector of pointers to BicyclePart representing the parts used to construct the bicycle. To initiate the construction of a bicycle, a technician calls BicycleBuilder::createproduct( ) on a derived BicycleBuilder object. The BicycleTechnician::construct( ) function calls all the functions in the BicycleBuilder interface (since it doesn’t know what type of concrete builder it has). The concrete builder classes omit (via empty function bodies) those actions that do not apply to the type of bicycle they build, as you can see in the following implementation file^.

//: C10:Bicycle.cpp {O}

// Defines classes to build bicycles

// Illustrates the Builder Design Pattern

#include

#include

#include

#include "Bicycle.h"

#include "../purge.h"

using namespace std;

// BicyclePart implementation

BicyclePart::BicyclePart(BPart bp) {

  id = bp;

}

ostream&

operator<<(ostream& os, const BicyclePart& bp) {

  return os << bp.names[bp.id];

}

std::string BicyclePart::names[NPARTS] = {

  "Frame", "Wheel", "Seat", "Derailleur",

  "Handlebar", "Sprocket", "Rack", "Shock"};

// Bicycle implementation

Bicycle::~Bicycle() {

  purge(parts);

}

void Bicycle::addPart(BicyclePart* bp) {

  parts.push_back(bp);

}

ostream&

operator<<(ostream& os, const Bicycle& b) {

  os << "{ ";

  for (size_t i = 0; i < b.parts.size(); ++i)

    os << *b.parts[i] << ' ';

  return os << '}';

}

// MountainBikeBuilder implementation

void MountainBikeBuilder::buildFrame() {

  product->addPart(new BicyclePart(BicyclePart::FRAME));

}

void MountainBikeBuilder::buildWheel() {

  product->addPart(new BicyclePart(BicyclePart::WHEEL));

}

void MountainBikeBuilder::buildSeat() {

  product->addPart(new BicyclePart(BicyclePart::SEAT));

}

void MountainBikeBuilder::buildDerailleur() {

  product->addPart(

    new BicyclePart(BicyclePart::DERAILLEUR));

}

void MountainBikeBuilder::buildHandlebar() {

  product->addPart(

    new BicyclePart(BicyclePart::HANDLEBAR));

}

void MountainBikeBuilder::buildSprocket() {

  product->addPart(new BicyclePart(BicyclePart::SPROCKET));

}

void MountainBikeBuilder::buildRack() {}

void MountainBikeBuilder::buildShock() {

  product->addPart(new BicyclePart(BicyclePart::SHOCK));

}

// TouringBikeBuilder implementation

void TouringBikeBuilder::buildFrame() {

  product->addPart(new BicyclePart(BicyclePart::FRAME));

}

void TouringBikeBuilder::buildWheel() {

  product->addPart(new BicyclePart(BicyclePart::WHEEL));

}

void TouringBikeBuilder::buildSeat() {

  product->addPart(new BicyclePart(BicyclePart::SEAT));

}

void TouringBikeBuilder::buildDerailleur() {

  product->addPart(new BicyclePart(BicyclePart::DERAILLEUR));

}

void TouringBikeBuilder::buildHandlebar() {

  product->addPart(

    new BicyclePart(BicyclePart::HANDLEBAR));

}

void TouringBikeBuilder::buildSprocket() {

  product->addPart(new BicyclePart(BicyclePart::SPROCKET));

}

void TouringBikeBuilder::buildRack() {

  product->addPart(new BicyclePart(BicyclePart::RACK));

}

void TouringBikeBuilder::buildShock() {}

// RacingBikeBuilder implementation

void RacingBikeBuilder::buildFrame() {

  product->addPart(new BicyclePart(BicyclePart::FRAME));

}

void RacingBikeBuilder::buildWheel() {