Question

I’m building a geometry library and I have some design issue.

I have this (simplified) design :

My base class is Geometry. It implements a method that computes the intersection of two geometries

class Geometry
{
    Geometry* intersection(Geometry* other)
    {
        //...compute intersection...
        //another lib does some work here
        Geometry* inter = compute_intersection()
        return inter;
    }
};

I also have some classes deriving from Geometry.

Let’s say I have :

class Point : public Geometry
{
};

and

class Polyline : public Geometry
{
};

My method intersection returns a geometry because I can’t know if the result of an intersection
is a Point or a Polyline. My problem comes when I want to use the resulting geometry.

Let’s say somewhere in my main, I do

Geometry* geom = somePolyline->intersection(someOtherPolyline);

I know that geom is actually a Polyline.
When I try to do

Polyline* line = dynamic_cast<Poyline*>(geom)

it returns a NULL pointer, which is normal since geom’s real type is not Polyline, it’s a Geometry.
I can try a reinterpret_cast but then I lose the polymorphic behaviour.

My question is : can I modify my intersection method in something like this :

Geometry* intersection(Geometry* other)
{
    //...compute intersection...
    Geometry* inter = compute_intersection()

    // the intersection is computed by another lib and I can check (via a string)
    // the real type of the returned geometry.

    // cast the result according to its real type
    if (inter->realType() == "Polyline")
        return dynamic_cast<Polyline*>(inter);
}

If it’s not a good idea (and I think it’s not), what would be a good design to do something like this ?

thanks in advance

(sorry for the poor question title, I couldn’t find something good)

Answer 1

Just create a Polyline object and return it:

Geometry* intersection(Geometry* other)
{
     Geometry* inter = 0; // Work out what it should be before creating it.

     // Work out what sort of thing it is ...

     if ( someCondition ) // which means it's a Polyline
         inter = new Polyline;

     return inter;
} 

Your function is essentially a factory as it creates differnt types of Geometry derivative. You’ll be returned a pointer to a Geometry but you can then dynamic_cast it to a Polyline if you want.