Question

I have the following code for ‘factory’ design pattern implementation.

class Pen{ public:      virtual void Draw() = 0; };  class RedPen : public Pen{ public:      virtual void Draw(){          cout << 'Drawing with red pen' << endl;      } };  class BluePen : public Pen{ public:      virtual void Draw(){          cout << 'Drawing with blue pen' << endl;      } };  auto_ptr<Pen> createPen(const std::string color){      if(color == 'red')          return auto_ptr<Pen>(new RedPen);      else if(color == 'blue')          return auto_ptr<Pen>(new BluePen); } 

But I heard that it can be done in a better way using ‘C++ templates’. Can anyone help how it is done and how template approach is better than this?

Any thoughts

Answer 1

In the example you posted, neither a factory or a template approach makes sense to me. My solution involves a data member in the Pen class.

class Pen { public:     Pen() : m_color(0,0,0,0) /* the default colour is black */     {                 }      Pen(const Color& c) : m_color(c)     {     }      Pen(const Pen& other) : m_color(other.color())     {     }      virtual void Draw()     {         cout << 'Drawing with a pen of color ' << m_color.hex();     }     void setColor(const Color& c) { m_color = c; }     const Color& color() const { return m_color; } private:     Color m_color; };  class Color { public:     Color(int r, int g, int b, int a = 0) :         m_red(r), m_green(g), m_blue(other.blue()), m_alpha(a)       {     }      Color(const Color& other) :          m_red(other.red()), m_green(other.green()),          m_blue(other.blue()), m_alpha(other.alpha())     {     }      int red() const { return m_red; }     int green() const  { return m_green; }     int blue() const { return m_blue; }     int alpha() const { return m_alpha; }      std::string hex() const     {         std::ostringstream os;         char buf[3];         os << '#';          sprintf(buf, '%2X', red());         os << buf;          sprintf(buf, '%2X', green());         os << buf;          sprintf(buf, '%2X', blue());         os << buf;          sprintf(buf, '%2X', alpha());         os << buf;          return os.str();     }  private:     int m_red;     int m_green;     int m_blue;     int m_alpha; } 

Of course, the color class would have to be adjusted to the drawing API you use — and perhaps be way more advanced than this one (different color spaces, etc).

Why not templates?

The reason it does not make sense to use templates, is that (presumably) the only difference between the different drawing operations is the color variable. So, by using templates (or manually declaring different classes, as you did), you will duplicate similar code. This will make your program large, and slow it down.

So, the draw function should either take the color as an argument, or (as in my example) have the color as a class data member.