Virtual classes and run-time performance

Hi all.

I have a large set of (x,y,z) point that I want to manipulate. Most of
the data (millions) are "regular" while exactly three points are
"special".

The points are well separated in the list of points, points 0,..,N-1
are "regular", any points at indexes >= N are "special".

The manipulations deal with quadruples of points. If all points
are "regular", then one set of operations take place. If any of
the points are "special", then another set of operations are
invoked. There could be 1, 2, or 3 "special" points involved in
each manipulation, but always at least one "regular" point.
The points are passed to the relevant functions in arbitrary
order, one does never know in advance if any points are
special, and if so, how many or where they appear in the
list of points that are involved in the manipulation.

So I have a couple of options when implementing this.

The naive way is to test, on every call of the function, whether
any points are "special", and if so, invoke the relevant functions.
The test is simple enough -- test index agains N -- but finding out
exactly which of the points are special, and respond to that, might
generate some more overhead. This would amount to some
overhead at every single call to the function.

The other strategy is to implement this as a class hierarchy
like this (very sketchy, no C++ docs available, general ideas
only are interesting, so please don't get hung up on syntax
details!):

class Point{
virtual void f(point,point,point)=0;
};

class RegularPoint : public Point{
virtual void f(RegularPoint,RegularPoint,RegularPoint);
virtual void f(SpecialPoint,RegularPoint,RegularPoint);
:
virtual void f(SpecialPoint,SpecialPoint,SpecialPoint);
// All 8 variants of type matches here. Most will be
// inetrfaces to generic functions for one and two special
// points, respectively. Maybe some extra overhead,
// maybe the compiler optimizes it away. But it will
// not affect the majority of operations.
};

class SpecialPoint{
virtual f(point,point,point){};
// This function will only be called from RegularPoint objects.
// That's THE distinction between regular and special points.
};

This way, the test about what method to call is done by
run-time type matching. Of course, this will be optimized
in the end, so one might be optimistic about performance.

Is there reason to expect the latter implementation to
perform particularly worse than the first approach, what
run-time is concerned? Have anybody tested the relative
run-time performance of these sorts of things?

I have used this trick in the past in applications where
run-time was not a concern. It surely makes the source
code a lot easier to maintain...

Rune

--
      [ See http://www.gotw.ca/resources/clcm.htm for info about ]
      [ comp.lang.c++.moderated. First time posters: Do this! ]