Question

I have a base class A and classes B and C are derived from it. A is an abstract class, and all three classes have a constructor that takes 2 arguments. Is it possible to make a method in the base class A like this:

A* clone() const
{
    return new this.GetType(value1, value2);
}

and if the current object whose clone()-function is being called is for example C, the function will return the pointer to a new object of class type C?

Answer 1

This looks like C++.NET (a.k.a. “managed C++”) rather than plain (standard) C++. I’m not an expert on this, but my guess (assuming .NET) would be that you’d have to use reflection to instantiate an object of a System.Type. The usual steps are:

1. Create or get a suitable Type object, e.g. by calling GetType.
2. Find a suitable ConstructorInfo (Type.GetConstructors() IIRC)
3. Call ConstructorInfo.Invoke() to create an instance
4. Cast the resulting System.Object to the desired type.

In regular C++, you can’t do this at all, because the language simply doesn’t have reflection, and type information is mostly lost at run time (RTTI can compare and test run-time types of objects, but that’s about it). You’ll have to implement a new clone method for each derived class; the pattern I usually use looks something like this:

class Foobar : public Baz {
  public:
    int extra; // public for demonstration purposes

    // Copy constructor takes care of actual copying
    Foobar(const Foobar& rhs) : Baz(rhs), extra(rhs.extra) { }

    // clone() uses copy constructor to create identical instance.
    // Note that the return type is Baz*, not Foobar*, so that inheritance works
    // as expected.
    virtual Baz* clone() const { return new Foobar(*this); }
};