Hi all.
I have an application where I have two main classes,
class A {...};
class B {...};
The application uses two vectors,
std::vector<A> vA;
std::vector<B> vB;
as well as a vector of references (by semantics, not
data type) to elements in the elements in the two vectors:
struct ref {
size_t aref;
size_t bref;
};
where the references aref and bref refer by index to elements
in vectors vA and vB, respectively.
There are lots of manipulator functions that manipulate the
ref arry, to maintain references to A and B elements that
somehow are related. The typical type signature of these
functions is
void foo(size_t ar,size_t br);
where indexes to both A and B elements are of type size_t.
With corresponding potential of mix-up and mayhem.
The simplest way of 'typifying' the references, is
class Aref_t : public size_t {
/* implement relevant assignment and arithmetic operators */
};
class Bref_t : public size_t {
/* implement relevant assignment and arithmetic operators */
};
The question is if this is enough to have the compiler complain
if the two types Aref_t and Bref_t get mixed up - both inherit from
the same base class. .
Are there other ways of doing this? I don't want to use structs,
since I don't want to use type.value kinds of references.
Rune
[ comp.lang.c++.moderated. First time posters: Do this! ]