Objectives

Explore the primary stl sequences, associations and adapters
Examine the implications of using inheritance and virtual functions with these containers
Gain an understanding of the memory management implications of storing references in containers
Use a simple auto pointer implementation to ease the burden of managing memory
Explore the ptr_container library, and gain an understanding of how it manages memory in this context.

Setup

Create a new project called lab08a_stl
Make sure the boost library

STL

In eclipse, create a folder in the src folder of the project called "sequences".
Into this folder incorporate the following source files:
list.cpp
vector.cpp
Create another folder call "associations", to incorporate these files:
set.cpp
map.cpp
Create folder called "adapters":
deque.cpp
stack.cpp
queue.cpp
priorityqueue.cpp
Create a folder called "iterators" containing:
iterators.cpp
Now create a folder called "utils", incorporating:
util.h
You project structure should start to look something like this:

incorporate the following main program into the "src" folder itself:
main.cpp
In order to compile, you will need to place "util" on the include path.
Build and test.

Shape Classes

Create a new folder called "shapes", and incorporate the following classes (all just headder files):
point.h
shape.h
ellipse.h
rectangle.h
In the same folder, introduce this source file:
poly.cpp
Adjust main.cpp to just call the function in this file only:

#include "util.h"

void vectest();
void listtest();
void dequetest();
void settest();
void maptest();
void stacktest();
void queuetest();
void priorityqueuetest();
void iteratortest();

void polytest1();

int main()
{
/*  vectest();
  listtest();
  dequetest();
  settest();
  maptest();
  stacktest();
  queuetest();
  priorityqueuetest();
  iteratortest();*/

  polytest1();
}

Build and test.
Can you explain the output?
Write a new function - polytest2(), such that shapes is an array of pointers.

void polytest2()
{
  Shape* shapes[2];
  shapes[0] = new Ellipse(Point (1,1), 10);
  shapes[1] = new Rectangle(Point(2,2), 20, 10);

  for (int i=0; i<2; i++)
  {
    shapes[i]->draw();
  }
}

Run the program again - what is the difference in the output?
The for loop can be rewritten using the boost foreach (include 'util.h' to get the definition):

  foreach (Shape *s, shapes)
  {
    s->draw();
  }

list of shapes

Introduce the following function:

void polytest3()
{
  Ellipse   e(Point (1,1), 10);
  Rectangle r(Point(2,2), 20, 10);

  list <Shape> shapeList;

  shapeList.push_back(e);
  shapeList.push_back(r);

  foreach (Shape &amp;s, shapeList)
  {
    s.draw();
  }
}

Build and test. Can you explain the result?
Change Shape::draw() to be a pure virtual:

  virtual void draw()=0;

Rebuild and test. Can you explain the error messages?
Try the following:

  list <Shape*> shapeList;

  shapeList.push_back(new Ellipse(Point (1,1), 10));
  shapeList.push_back(new Rectangle(Point(2,2), 20, 10));

  foreach (Shape *s, shapeList)
  {
    s->draw();
  }
}

Build and test.
Notice that the objects are never deleted. Introduce a the code (perhaps using the foreach) to delete all of the shapes form the list.
Consider introducing a subclass of list - which would have a destructor which could carry out this cleanup.
This is a potential class here:

template <typename T>
struct mylist : public list<T>
{
  mylist()
  {}

  virtual mylist()
  {
    foreach (T &amp;s, *this)
    {
     delete s;
    }
  }
};

Verify that cleanup happens with this example here:

  mylist <Shape*> shapeList;

  shapeList.push_back(new Ellipse(Point (1,1), 10));
  shapeList.push_back(new Rectangle(Point(2,2), 20, 10));

  foreach (Shape *s, shapeList)
  {
    s->draw();
  }

Ref2

Introduce the following smart pointer class into your project:

#pragma once

template < class T >
class Ref2
  {
  public:
    Ref2(const T &amp;s)                           {KillData = true;  t = s.clone();}
    Ref2(T *s)                                 {KillData = false; t = s;}
    Ref2(const Ref2 < T > &amp;r)                  {KillData = true;
                                                t = r.t?r.t->clone():NULL;}
    Ref2()                                    {if (t &amp;&amp; KillData) delete t;}
    Ref2&amp; operator= (const Ref2 < T > &amp; r)     {if (t &amp;&amp; KillData) delete t;
                                                KillData = true;
                                                t = r.t?r.t->clone():NULL;
                                                return *this; }
    T* operator->() const                      {return t;}
    int operator< (const Ref2 < T > &amp; r) const {return t?r.t?(*t) < (*r.t):false:true;}
    operator T&amp;()   const                      {return *t;}
    operator T*()   const                      {return t;}
    T&amp; operator*()  const                      {return *t;}
  protected:
    T *t;
  private:
    bool KillData;
  };

We can reformulate the shape examples to use this class:

  list <Ref2 <Shape> > shapeList;
  shapeList.push_back(Ellipse(Point (1,1), 10));
  shapeList.push_back(Rectangle(Point(2,2), 20, 10));

  foreach (Shape *s, shapeList)
  {
    s->draw();
  }

Compilation will fail - as this template requires a "clone" method in the shape classes.
Introduce these now:

  // Shape...
  virtual Shape* clone() const
  {return 0;};

  //... Ellipse...
  Shape* clone() const
  {
   return new Ellipse(origin, radius);
  }

  //... Rectangle..
  Shape* clone() const
  {
    return new Rectangle(origin, width, height);
  }

Build and test
Can you account for all of the objects being created/destroyed?
What happens if the following is introduced:

  static Ellipse persistentEllipse(Point(20,20), 22);
  shapeList.push_back(&amp;persistentEllipse);

Now try this one:

  list <Ref2 <Shape> > shapeList;
  shapeList.push_back(new Ellipse(Point(20,20), 22));

Do you observe any differences?

ptr_container

Now include the ptr_conainer library into your test code:

#include <boost/ptr_container/ptr_list.hpp>
using namespace boost;

Now try the following:

  ptr_list <Shape>  shapeList;

  shapeList.push_back(new Ellipse(Point (1,1), 10));
  shapeList.push_back(new Rectangle(Point(2,2), 20, 10));

  ptr_list <Shape>::iterator i;
  for (i=shapeList.begin(); i##=shapeList.end(); i++)
    i->draw();

  foreach (Shape &amp;s, shapeList)
  {
    s.draw();
  }

Remove all the other code - so you can just track the objects within this fragment only.

Exercises

STL Lab Archive

stl.zip

Exercise 1: ptr_container

Rework the last lab to use
ptr_container library
boost foreach loops.

Exercise 2: Camera

In earlier labs, we implemented a rudimentary mechanism for navigation a scene. Propose and implement a design whereby this is modeled as a Camera abstraction - that is placed within a scene and can be moved around via some keybaord sequences