Is it possible to return a derived class from a base class method in C++?

Question

I would like to do this:

class Derived;

class Base {
    virtual Derived f() = 0;
};

class Derived : public Base {
};

Of course this doesn't work since I can't return an incomplete type. But neither can I define Derived before base, since I can't inherit from an incomplete type either. I figure that I could use templates as a workaround (using Derived as a template argument to Base), but it seems a really ugly way of doing things. Might there be another way?

Elaboration: I'm writing a raytracer, and each Shape class has a function which returns its bounding box. However, I've made the BBox a subclass of Shape, so I can visualize it. Is this bad design?

Answer 1

You could use a pointer (or a reference):

class Derived;

class Base {
    virtual Derived *f() = 0;
};

class Derived : public Base {
};

But this is code smell to me. Why should anybody inheriting from this class need to know about another derived class? In fact, why should the base class be concerned with it's derivee's?

For your situation, you'll need to notice things that mgiht be a signal for bad design. Although it makes sense that your bounding box would derive from Shape, keep in mind, since Shape has a function that returns a bounding box, a bounding box will have a function that returns itself.

I'm not sure the best solution, but you could make BBox a separate class altogether, and perhaps give it a function akin to: Shape *as_shape(void) const, which would construct a class Box : public Shape with the same dimensions as the bounding box.

I still feel there is a better way, but I'm out of time for now, I'm sure someone else will think of a better solution.

Answer 2

I'd go with returning a pointer to a Base, so that Base doesn't need to know about Derived or anything else that comes along later:

class Base {
  virtual Base *f() = 0;
};

class Derived : public Base {
  virtual Base *f();
};

Base *Derived::f() {
  Derived *r = new Derived;
  return r;
}

Answer 3

Why not just do:

class Base {
    virtual Base *f() = 0;
};

Answer 4

There's nothing wrong with the code in your question. This

class Derived;

class Base {
    virtual Derived f() = 0;
};

class Derived : public Base {
    virtual Derived f() {return Derived();}
};

should compile just fine. However, callers of 'Base::f()' will need to have seen the definition of 'Derived`.

Answer 5

As others have pointed out, the code sample you have can be made to work, but that you probably mean to return a pointer to the base class from 'f'.

In your elaboration, you mention that the bounding box is a subclass of shape, but there is a problem:

class Shape{
    virtual Shape* getBoundingBox() = 0;
};

class Square: public Shape{
    virtual Shape* getBoundingBox();
};
class BBox: public Shape{
    virtual Shape* getBoundingBox(); // Whoops! What will BBox return?
};

Lets move some of the responsibilities around:

class Shape{
    virtual void draw() = 0; // You can draw any shape
};
class BBox: public Shape{
    virtual void draw(); // This is how a bounding box is drawn
};

class BoundedShape: public Shape{
    virtual BBox* getBoundingBox() = 0; // Most shapes have a bounding box
};

class Square: public BoundedShape{
    virtual void draw();
    virtual BBox* getBoundingBox(); // This is how Square makes its bounding box
};

Your application will now probably need to hold collections of BoundedShape* and occasionally ask one for its BBox*.

Answer 6

Your notion about templates wasn't necessarily a bad one. What you describe is called the Curiously Recurring Template Pattern.

An example:

#include <iostream>

template <typename T>
struct Base
{
    virtual T* foo() = 0;
};

struct Derived : Base<Derived>
{
    virtual Derived* foo() { return this; }
};