How to design classes for my little problem

Hi,

I'm writing a program that should handle vectors of homogeneous type
T and length N. At run-time, the program reads from a file
specification all the informations: which type is T (bit, integer,
float or double),
the value of N and how many vector are stored in the file.
These vectors must belong to a metric space, so it is necessary to
define a GetDist() method.

For float, double, int i use the Euclidean distance. For bit vectors
i use the Hamming distance (since 32-bit are packed in one int on most
current machines,
the hamming distance code is fast and the memory requirements are
lower).
In addition, i may want to implement a function GetElemAt (int
index) ..

I would then place those vectors in a container.

I have another class that implements an algorithm to approximate
nearest neighbors searching
(class ANN). I plan to implement
different types of these algorithms (ball-tree, vp-tree, lsh, k-
meanstree
etc. ...), so I thought i would write a simple basic interface and
then derive the various implementations.
In any case, these search algorithms use the vector container
mentioned above. At object-construction time, these algorithms in
inserts all the vectors of the container in an appropriate data
structure. At search time, a ANN algorithm use its special data-
structure
to find the K nearest neighbors of a given query vector.
Obviously, the query vector and those stored in the container must be
exactly

of the same type. I do not think we need to make comparisons element-
by-element, but it may be necessary (in case
positive, it would be necessary the GetElemAt() method above).

Finally, I have a class with a method that takes only a vector
container and an object of type ANN and performs matching between
each
element of the container with its nearest element stored in the ANN
data structure

How to return this result (which type of class)?

How to design this?

Even a simple idea could help me.
Right now, i was thinking about a generic vector container interface
thas is based on handles.
For example:

class IVectorContainer
{
public:
virtual void * GetElem (const void * handle) const = 0;
};

The specific implementations of the derived class will
interpret the handle and will return the item accordingly.
In addition, the vector class interface could be of the type:

class IVector
{
public:
virtual float getdist (IVector const * v) const = 0;
};

Now, this method also works for vectors of bits (the Hamming distance
is an integer number, however,
so it is an ugly thing to return a float, but it works...).
But how would implement a GetElem() method?

Template? But the nature of my vector type is established at run-time
(read from a file) ...

Help!

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