Thread: Interface with method that return other implementation of the same Interface

You can not create an instance of an abstract/interface class, which is why you can not return an instance.
You can, however, return a pointer/reference to an abstract class, which is created from a an instance of a (concrete, without abstract functions) derived class. This is the basis of polymorphism, and probably what you want to do.
You have to watch out though, when returning a pointer, it has to point to an instance that is still alive after the function has finished.
Usually this is a (maybe const?) reference to a member of the class, and then the user is responsible for keeping the class around so the member will still exist when using the returned instance.
Or you create a new instance on the heap inside the function and return a pointer to that instance, this instance then will outlive the scope of the function. By using new, not recommended as the user of that class/function now has to know it has to call delete at some point, or with a smart pointer like std::unique_ptr<IWizardPage>, which is what I probably would do in the case you are not returning a pointer to a member of the class.
In a derived class you then implement this abstract function and at some point you create the std::unique_ptr preferably with a call like

Code:

auto derived_instance = std::make_unique<DerivedWizardPage>(derived_wizard_page_constructor_arguments_if_needed);

and return that instance.

For a, hopefully clear, working example see
[Wandbox]三へ( へ՞ਊ ՞)へ ﾊｯﾊｯ

By design since it is meant to be an interface, your class is an abstract base class, therefore it is impossible to create objects of the class, hence it is impossible for ProcessPage to return an object.

Your options:

• Return a reference. This especially makes sense if the object to be returned already exists separately, but it sounds like the method overrides will be invoking a derived class constructor, so maybe not.
• Return a pointer to a new object. This is likely to be what you're looking to do.
• Return a smart pointer, in particular a std::unique_ptr<IWizardPage>, to a new object. This is the same as the previous option, except that you preempt memory leaks from the start.

EDIT:

Originally Posted by Frydac

For a, hopefully clear, working example see
[Wandbox]三へ( へ՞ਊ ՞)へ ﾊｯﾊｯ

Unfortunately that example doesn't declare the base class destructor to be virtual, and I notice that's missing from gil900's IWizardPage too. Without that, the unique_ptr to base class approach results in undefined behaviour since it destroys the derived class object through a base class pointer. That it is an interface with no member variables of its own reduces the problem, but it is still undefined behaviour.

Originally Posted by laserlight

[...]

Unfortunately that example doesn't declare the base class destructor to be virtual, and I notice that's missing from gil900's IWizardPage too. Without that, the unique_ptr to base class approach results in undefined behaviour since it destroys the derived class object through a base class pointer. That it is an interface with no member variables of its own reduces the problem, but it is still undefined behaviour.

ooch! Indeed.

same example with virtual destructor:
[Wandbox]三へ( へ՞ਊ ՞)へ ﾊｯﾊｯ

This illustrates you always want to use tools like gcc/clang address sanitizers, or msvc /RTC (Run-Time Error Checks, though I'm not sure if this would catch the absence of the virtual destructor) and use tools like valgrind (don't know about a windows alternative).