class AbstractHandle {  AbstractClass* ptr;  public:  // Unary operator* is the "dereference operator", which allows you to give  // pointer-like semantics to the class.  AbstractClass& operator*() { return *ptr; }  // And a similar overload so the -> operator will work. This one is a little  // trickier conceptually, but IIRC this is how it should be written:  AbstractClass* operator->() { return ptr; }  // And now all the wrapper RAII stuff.  // This constructor will "take ownership" of the pointed-to thing; the calling  // code should *not* delete the object. You would normally call this like:  // AbstractHandle x(new DerivedClass());  AbstractHandle(const AbstractClass* ptr): ptr(ptr) {}  // This version makes a copy of the passed in object and owns the copy. This  // works for a stack-allocated object:   // DerivedClass x;  // AbstractHandle y(x);  AbstractHandle(const AbstractClass& obj): ptr(obj.clone()) {}  // Copy construction. This facilitates the std::map copying.  AbstractHandle(const AbstractHandle& h): ptr(h->clone()) {}  // When you have copy construction, you normally need to write an   // assignment operator and destructor as well. This is no exception.  AbstractHandle& operator=(const AbstractHandle& other) {    // The copy-and-swap idiom shown here provides exception safety    // and implicitly ensures that self-assignment is correct.    AbstractHandle h(other);    std::swap(ptr, h.ptr);    // The AbstractClass that the current object used to point at will be    // destructed when 'h' falls out of scope.  }  ~AbstractHandle() { delete ptr; }};// Now you write your AbstractClasses using the appropriate idiom, and then// you can copy maps "directly", e.g.// std::map<int, AbstractHandle> tmp(original);