KISS — принцип проектирования, содержащий все остальные принципы проектирования

void DoHatchArea(Rectangle&, Rectangle&);
void DoHatchArea(Rectangle&, Ellipse&);
void DoHatchArea(Rectangle&, Poly&);
void DoHatchArea(Ellipse&, Poly&);
void DoHatchArea(Ellipse&, Ellipse&);
void DoHatchArea(Poly&, Poly&);

void DoubleDispatch(Shape& lhs, Shape& rhs)
{
    if(Rectangle* p1 = dynamic_cast<Rectangle*>(&lhs))
    {
        if(Rectangle* p2 = dynamic_cast<Rectangle*>(&rhs))
            DoHatchArea(*p1, *p2);
        else if(Ellipse* p2 = dynamic_cast<Ellipse*>(&rhs))
            DoHatchArea(*p1, *p2);
        else if(Poly* p2 = dynamic_cast<Poly*>(&rhs))
            DoHatchArea(*p1, *p2);
        else
            Error("Неопределенное пересечение");
    }
    else if(Ellipse* p1 = dynamic_cast<Ellipse*>(&lhs))
    {
        if(Rectangle* p2 = dynamic_cast<Rectangle*>(&rhs))
            DoHatchArea(*p2, *p1);
        else if(Ellipse* p2 = dynamic_cast<Ellipse*>(&rhs))
            DoHatchArea(*p1, *p2);
        else if(Poly* p2 = dynamic_cast<Poly*>(&rhs))
            DoHatchArea(*p1, *p2);
        else
            Error("Неопределенное пересечение");
    }
    else if(Poly* p1 = dynamic_cast<Poly*>(&lhs))
    {
        if(Rectangle* p2 = dynamic_cast<Rectangle*>(&rhs))
            DoHatchArea(*p2, *p1);
        else if(Ellipse* p2 = dynamic_cast<Ellipse*>(&rhs))
            DoHatchArea(*p2, *p1);
        else if(Poly* p2 = dynamic_cast<Poly*>(&rhs))
            DoHatchArea(*p1, *p2);
        else
            Error("Неопределенное пересечение");
    }
    else
    {
        Error("Неопределенное пересечение");
    }
}

class HatchingExecutor
{
public:
    //Разные алгоритмы штризовки области пересечения
    void DoHatchArea(Rectangle&, Rectangle&);
    void DoHatchArea(Rectangle&, Ellipse&);
    void DoHatchArea(Rectangle&, Poly&);
    void DoHatchArea(Ellipse&, Poly&);
    void DoHatchArea(Ellipse&, Ellipse&);
    void DoHatchArea(Poly&, Poly&);

    //Функция для обработки ошибок
    void OnError(Shape&, Shape&);
};

template<
    class Executor,
    class BaseLhs,
    class TypesLhs,
    class BaseRhs = BaseLhs,
    class TypesRhs = TypesLhs,
    typename ResulType = void
>
class StaticDispatcher
{
    typedef typename TypesLhs::Head Head;
    typedef typename TypesLhs::Tail Tail;
public:
    static ResultType Go(BaseLhs& lhs, BaseRhs& rhs, Executor& exec)
    {
        if(Head* p1 = dynamic_cast<Head*>(&lhs))
        {
            return StaticDispatcher<
                Executor, 
                BaseLhs, NullType, 
                BaseRhs, TypesRhs>::DispatchRhs(*p1, rhs, exec);
        }
        else
        {
            return StaticDispatcher<
                Executor,
                BaseLhs, Tail,
                BaseRhs, TypesRhs>::Go(lhs, rhs, exec);
        }
    }

    template<class SomeLhs>
    static ResultType DispatchRhs(SomeLhs& lhs, BaseRhs& lhs, Executor& exec)
    {
        typedef typename TypesRhs::Head Head;
        typedef typename TypesRhs::Tail Tail;

        if(Head* p2 = dynamic_cast<Head*>(&rhs))
        {
            return exec.Fire(lhs, *p2);
        }
        else
        {
            return StaticDispatcher<
                Executor,
                SomeLhs, NullType,
                BaseRhs, Tail>::DispatchRhs(lhs, rhs, exec);
        }
    }
}

template<
    class Executor,
    class BaseLhs,
    class BaseRhs,
    class TypesRhs,
    typename ResultType
>
class StaticDispatcher<
    Executor,
    BaseLhs, NullType,
    BaseRhs, TypesRhs,
    ResulType>
{
    static void Go(BaseLhs& lhs, BaseRhs& rhs, Executor& exec)
    {
        exec.OnError(lhs, rhs);
    }
}

template<
    class Executor,
    class BaseLhs,
    class TypesLhs
    class BaseRhs,
    class TypesRhs,
    typename ResultType
>
class StaticDispatcher<
    Executor,
    BaseLhs, TypesLhs,
    BaseRhs, NullType,
    ResulType>
{
    static void DispatchRhs(BaseLhs& lhs, BaseRhs& rhs, Executor& exec)
    {
        exec.OnError(lhs, rhs);
    }
}

typedef StaticDispatcher<
    HatchingExecutor, Shape,
    TYPELIST_3(Rectangle, Ellipse, Poly)> Dispatcher;
Shape* p1 = ...;
Shape* p2 = ...;
HatchingExecutor exec;
Dispatcher::Go(*p1, *p2, exec);