Question

Let’s say I have a class called MyClass, which has two member variables (both being int) called firstNumber_ and secondNumber_. This class also has a method called clone( ) which creates a new instance of the object with the same values and returns that new instance.

The question is, when returning a new instance of the class, do I return it as a pointer, a reference, or just the instance itself?

// MyClass.h
class MyClass {
private:
    int firstNumber_;
    int secondNumber_;

public:
    MyClass( int numA, int numB ) {
         firstNumber_ = numA;
         secondNumber_ = numB;
    }

    ~MyClass( ) { };

    // This method creates a copy of the object and returns that object.
    // The ( ? ) is there because I am not sure what type the returned value is.
    MyClass ( ? ) clone( ) {
         // Do I just return the new instance? Or do I need to return a reference or a pointer of the new instance?
         return MyClass( firstNumber_, secondNumber_ );
    }
};

What’s the proper way of achieving this? Note that MyClass does not inherit from any other classes.

Thanks in advance.

Answer 1

The method clone() is usually for returning a pointer to an instance of a polymorphic type, so you can call it on a pointer of the base type and get an pointer to an instance of the right derived type. For simple copying, in C++ you use the copy constructor, not a clone method.

Clone method:

struct Base{};
struct Foo : Base 
{
  Base* clone() const { return new Foo(*this); }
}:

Base * b1 = new Foo;
...
Base * b2 = b1->clone(); // points to a Foo instance, copy of object pointed at by b1

Where the clone method us using the (compiler generated) copy constructor.

Using copy constructor:

Foo f1;
Foo f2 = f1; // copy assignment

In real code you should prefer smart pointers over the raw ones used in these examples.

Concerning the return value, by default you should return by value, although in the polymorphic clone() example this would defeat the purpose by slicing the return object into a Base. So we return a pointer to an instance allocated dynamically. The intent and ownership has to be clear: in this case, the caller owns the pointer, and is responsible for deallocating it. Pre-c++11 you would have to rely on documentation to convey this. In C++11 you can use the smart pointer std::unique_ptr, which enforces the ownership and states it clearly.