抽象基类：如何为包含指向（抽象）基类的指针的类定义复制构造函数或赋值运算符？

Question

I just encountered with question on parashift.com regarding Abstract base classes in c++ .

Author has provided the solution in which pure virtual member function Clone() has been created in Abstract Base Class.The purpose of this function is to create and return the address of clone object of ABC pointing to. Here I am bit confused that what is the use of creating this virtual function and overriding the Assignment operator and copy constructor if we achieve the same thing without doing this.

class Shape {

    public:
      // ...
      virtual Shape* clone() const = 0;   // The Virtual (Copy) Constructor
      // ...
};

Then we implement this clone() method in each derived class. Here is the code for derived class Circle:

class Circle : public Shape {

public:

  // ...
  virtual Circle* clone() const;
  // ...

};

Circle* Circle::clone() const
{
  return new Circle(*this);
}

Now suppose that each Fred object “has-a” Shape object. Naturally the Fred object doesn't know whether the Shape is Circle or a Square or … Fred's copy constructor and assignment operator will invoke Shape's clone() method to copy the object:

class Fred {
public:
  // p must be a pointer returned by new; it must not be NULL
  Fred(Shape* p)
    : p_(p) { assert(p != NULL); }
 ~Fred()
    { delete p_; }
  Fred(const Fred& f)
    : p_(f.p_->clone()) { }
  Fred& operator= (const Fred& f)
    {
      if (this != &f) {              // Check for self-assignment
        Shape* p2 = f.p_->clone();   // Create the new one FIRST...
        delete p_;                   // ...THEN delete the old one
        p_ = p2;
      }
      return *this;
    }
  // ...
private:
  Shape* p_;
};

As I think we can achieve above behavior without overriding the Assignment operator or copy constructor. If we have two object f1 (P_ pointing to Circle) and f2 (P_ pointing to Square) of type Fred. then

f1=f2;  // This line exhibits the same behavior what  above code is doing. 

In the default case , P_ (Address of Square) of f2 will get copied to P_ to f1 . now f1 will point to Square. Only thing we need to take care is to delete the object of Circle otherwise it will be dangling state.

Why has the author mentioned the above technique to solve this problem? Please Advise.

Answer 1

It is true that you can do

delete f1.p;
f1 = f2;

But this means that the user of the Fred class – who is not necessarily the author of it – is required to know that he has to call delete f1.p first. It might be obvious to you now, but other people would be very surprised that a simple assignment causes memory leaks. Also, if you return to your code after a long time, maybe you forget this little rule yourself and do the mistake.

Since you always have to delete the shape before assigning Fred, it is absolutely sensible to write this in the overriden equals operator. So the deletion happens automatically and the user does not need to worry about it.

EDIT to answer question in comment :

The virtual Shape *clone() function in the base class enforces every derived class to implement the clone() function. If you derive from Shape and forget to implement clone() , your code will not compile. This is good because the overriden assignment operator of Fred relies on it.

Answer 2

In this case you want to make a deep copy of your Fred object. Since the destructor does a delete p_; , if you had two Fred objects pointing at the same Shape , you would get a double free error. The reason for the clone() interface is that Fred doesn't know what type of object p_ points at, so it can't directly call the correct copy constructor. Instead it relies on Shape 's subclasses to create copies of themselves and uses virtual method dispatch to create the right type of object.

Answer 3

The example is not trying to make an assignment of f2 to f1, so the OP's belief that f1 = f2; exhibits the same behaviour is incorrect. The example is assigning a copy of f2 to f1, so the behaviour is closer to f1 = new Whatever_f2_Is(*f2) .

Since f2 is a pointer to a base class, there isn't enough information at this point to know which copy constructor to use (a slight lie, but the clone method is still easier to use). You cannot call new Shape() even if shape wasn't pure virtual and thus uninstantiatable because shape does not know the extra information of the sublclass. You would have a Shape, but lose all of the extra aspects of Circle-ness or Square-ness.

Fortunately while we know nothing about what is really at f2, the object at f2 still knows what it is, and we can delegate the creation of the copy to it. That's what the clone method does for you.

The alternative is to play is-a games or use a ID code and a factory.