Re: Virtual inheritance & covariant return types
* kikazaru:
Is it possible to return covariant types for virtual methods inherited
from a base class using virtual inheritance?
Yes.
I've constructed an example below, which has the following structure:
Shape = base class
Triangle, Square = classes derived from Shape
Prism = class derived from Shape
TriangularPrism, SquarePrism = classes derived from Triangle and
Prism, or Square and Prism respectively
This seems to me an ungood hierarchy. A prism is a 3D shape, a triangle
is 2D shape. How can a prism be a triangle? Instead, I'd say a
triangular prism /has/ a triangle as one of its aspects. With that IMO
better design you avoid the multiple inheritance.
Prism provides some functionality based on virtual methods specified
in the Shape base class instantiated in specific Shapes Triangle and
Square. Since TriangularPrism and SquarePrism inherit Shape via Prism
AND Triangle/Square, it is necessary for Prism, Triangle and Square to
inherit Shape virtually.
I added a virtual Shape* clone() function to Sh7ape, and wanted to
return Triangle* for Triangle::clone(), SquarePrism* for
SquarePrism::clone() etc. but this did not compile. I had to return
Shape* for every version of clone(). This means that if I clone a
SquarePrism, I have to use a dynamic cast to get at the methods
specific to that class.
Is this right!? Is it simply impossible to use covariant return types
for methods inherited virtually from a base class?!
----------------- Code example:
#include "iostream"
Make that
#include <iostream>
class Shape {
public:
virtual double area() = 0;
virtual Shape* clone() = 0;
virtual char* type() { return "Shape"; }
};
Presumably at least the last two member functions should be 'const', and
with natural assumption of immutable objects, also the first.
// Shape must be inherited virtually in order to resolve multiple
inheritance in SquarePrism
class Square : virtual public Shape {
double length;
public:
Square(double l) : length(l) {}
virtual double area() { return length * length; }
// Use of the covariant return type Square* causes a compilation
error because Shape is inherited virtually
// The error reads: "sorry, unimplemented: adjusting pointers
for covariant returns"
// virtual Square *clone() { return new Square(*this); }
virtual Shape *clone() { return new Square(*this); }
virtual char* type() { return "Square"; }
};
The covariant version should compile just fine. Upgrade your compiler,
or use some other compiler. Even if you change the design as noted
above. If you can't change the design, and can't upgrade the compiler
and use some other compiler, then nothing prevents from localizing the
downcast in each class. Simply provide a member function cloneAsSquare.
[snip]
sp.clone()->volume() << endl;
Here you should have
cout << sp.clone()->volyume() << endl;
I guess you're aware that the code as-is leaks memory.
--
A: Because it messes up the order in which people normally read text.
Q: Why is it such a bad thing?
A: Top-posting.
Q: What is the most annoying thing on usenet and in e-mail?