workaround for auto_ptr<> in STL containers?

Hi,

I'm stuck in a rather standard situation that may therefore be best
illustrated with a standard example, i.e. a graphics library offering a
bunch of shapes.

I want to allow the user to create shapes at _runtime_ as desired, so
all my shapes are derived from an abstract Shape class, allowing me to
both keep track of all the created shape objects in a list and to clone
new shape objects from the available shapes depending on user input, e.g.:

#include <iostream>
#include <typeinfo>
#include <vector>
struct Shape {
     virtual ~Shape() {}
     virtual Shape *Clone() = 0;
     void Register() {Templates.push_back(this);}
     static std::vector<Shape *> Templates;
};
std::vector<Shape *> Shape::Templates;
struct Circle: Shape {
     Circle() {Register();}
     Circle(int radius) {std::cout << "Creating circle.\n";}
     Circle *Clone() {
         std::cout << "radius? " << std::flush;
         int radius;
         std::cin >> radius;
         return new Circle(radius);
     }
     static Circle Template;
};
Circle Circle::Template;
struct Rectangle: Shape {
     Rectangle() {Register();}
     Rectangle(int height, int width) {std::cout << "Creating
rectangle.\n";}
     Rectangle *Clone() {
         std::cout << "height, width? " << std::flush;
         int height, width;
         std::cin >> height >> width;
         return new Rectangle(height, width);
     }
     static Rectangle Template;
};
Rectangle Rectangle::Template;
int main() {
     int number;
     long address;
     while(std::cin.good()) {
         std::cout << "Enter number to create a shape:\n";
         for(unsigned int i = 0; i < Shape::Templates.size(); i++) {
             std::cout << i << ": " <<
typeid(*(Shape::Templates[i])).name() << std::endl;
         }
         std::cin >> std::dec >> number;
         Shape::Templates[number]->Clone();
     }
}

In the example, I used pointer semantic to exploit polymorphism, which
is fine for this simple case, but tracking deletion of objects quickly
becomes difficult in more complex scenarios. Thus, I considered using
std::auto_ptr<> to overcome this, but auto_ptr<> does not seem to be
compatible with STL containers, where I want to keep my shapes in some
sort of list.

Any ideas how this (i.e. auto-deletion of unreferenced objects) could be
handled in a generic way while using STL containers?

Thanks for any suggestions,

Christof