Consistencia de tipos entre clases relacionadas

[argentinator]

Hola.
Tengo este problema.
He definido una clase Data, que contiene varios datos complicados, pero eso no importa mucho.
Lo importante es que dentro de Data tengo un vector, digamos VEC, y accedo a sus elementos mediante una variable entera POSITION.
Una llamada tipica es:

VEC[POSITION] = XXXXX;

Ahora bien. Uno de los miembros de Data es una clase sencilla,
llamada Indexer,
que se encarga de hacer ciertas operaciones con los índices,
y por lo tanto algunos de sus miembros son variables de tipo entero.

Lo que necesito es una manera de asegurar que los tipos ENTEROS que uso en los métodos de Data, tanto como en sus variables internas, coincidan con el tipo ENTERO que uso en Indexer.

Código:

class Indexer
{
    public:
      Indexer(void);
      ~Indexer();

      unsigned long int the_index_is() { return index; }
   private:
       unsigned long int index;
}

class Data
{
   public:
      Data(void); 
      ~Data();

      vector<vaquitas> VEC;
      vector<terreno>   TERR;

      void arrear(void)
            {
                   Indexer VaquitaQueEscapa;

                   unsigned long int POSITION = 1;

                   if (VEC[VaquitaQueEscapa.the_index_is()] == TERR[POSITION])
                             arrear();
                        
            };

    
};

Como se puede ver, ambas clases, Indexer y Data, son distintas, aunque Data usa variables de tipo Indexer.
No obstante, tengo que declarar que el tipo de datos de Indexer.Index tanto como de la variable POSITION, del mismo tipo entero, por ejemplo: unsigned long int.

Esto es un lío si ambas clases están en archivos separados, y si deben haber más clases compatibles con Indexer.

Al parecer, las clases de tipo "vector" en c++ no se preocupan por el tipo del índice del vector, pero cuando necesito hacer operaciones aritméticas con esos índices, es necesario ir más allá de los iteradores, y usar una clase que controle los índices de forma inteligente, como mi Indexer.

La primer solución que intenté fue definir un tipo de datos: My_Integer, y repetirlo en todas partes. Pero eso requiere que la declaración

typedef long int My_Integer;

esté visible desde todos los archivos .h.

Podría definirlo en el archivo "Indexer.h", para que esté visible para todos los que la usan, pero eso me parece "extraño a la filosofía de POO", porque el tipo de datos My_Integer, está ligado a la clase Indexer por la necesidad del programa, pero no está formalmente incluido en la definicion de la clase.

Podría definirlo dentro de la clase, pero me parece poco el tipo My_Integer es un tipo de datos que requiero en varias clases distintas, incluso algunos que no usan a Indexer.

Necesito definir un tipo de datos My_Integer que esté ligado a todas las clases que voy a usar, pero no son hijas unas de otras, sino sólo relacionadas entre sí, parcialmente.

¿Sería apropiado definir un espacio de nombres?

Otra solución que intenté fue la siguiente: definir todas las clases en cuestión como templates de la forma:

Código:

template <class Algun_Tipo_Entero>
class Indexer{
...
};

template <class Algun_Tipo_Entero>
class Data{
...
};

De esa manera, usaría el tipo genérico Algun_Tipo_Entero cada vez que invoco un subíndice, y las clases que están relacionadas entre sí, automáticamente invocarian ese tipo entero. Por ejemplo, al definir una variable de tipo Indexer dentro de Data, haria algo como esto:

Código:

   template <class Algun_Tipo_Entero>
  void arrear<Algun_Tipo_Entero>(void)
            {
                   Indexer<Algun_Tipo_Entero> VaquitaQueEscapa;

                   Algun_Tipo_Entero POSITION;

                   if (VEC[VaquitaQueEscapa.the_index_is()] == TERR[POSITION])
                             arrear();
                        
            };

Entonces el tipo entero usado por Indexer sería el mismo que el de Data.

Esta solución me gustó, pero no funciona, porque cuando quiero hacer algo como POSITION++, el compilador no sabe que POSITION es un entero, y no puedo seguir.

Me parece tedioso tener que redefinir todos los operadores aritméticos en un caso como ese.

Me gustaria saber si hay alguna forma de indicarle al compilador que la etiqueta Algun_Tipo_Entero corresponde, efectivamente, a algún tipo de datos de C++ que es entero, haciendo válidas automáticamente las operaciones aritméticas.

He visto por ahí que se pueden porner restricciones en los parámetros de los templates, pero no sé si se puede hacer esto que necesito.