Básicamente, quiero tener una clase de contenedor base que pueda devolver un iterador genérico que pueda usarse para atravesar una instancia de la clase de contenedor, sin necesidad de especificar plantillas de iterador. Creo que no puedo implementar el contenedor base sobre una plantilla de clase, lo que requeriría un algoritmo transversal basado en clases de plantilla que no se conocen de antemano. El contenedor base se puede heredar e implementar utilizando cualquier tipo / implementación de contenedor (personalizado o estándar) dentro. Aquí hay algunos ejemplos de código para que quede claro:

struct MyObject {
  int myInt;
}

// an abstract container
class BaseContainer {
public:
  virtual void insertMyObject(MyObject& obj) = 0;
  virtual iterator getFirst(); // the iterator type is for demonstration purposes only
  virtual iterator getLast();  // the iterator type is for demonstration purposes only
}

// Sample container class that uses a std::vector instance to manage objects
class BaseContainer_Vector : public BaseContainer {
public:
  void insertMyObject(MyObject& obj); // e.g. just pushes back to the vector
  iterator getFirst(); // needs to override the iterator?
  iterator getLast();  // needs to override the iterator?
private:
  std::vector<MyObject> objectContainer;
}

Luego tendré una lista de objetos de contenedor, y quiero iterar sobre estos contenedores y los objetos almacenados.

std::vector<MyContainer*> containers;
for(int i=0 ; i<containers.size() ; i++){
  iterator i    = containers[i]->getFirst();
  iterator iend = containers[i]->getLast();
  for(; i != iend ; i++) {
    std::cout << (*i).myInt << std::endl;
  }
}

Además, me gustaría tener soporte para impulsar la declaración macro de foreach. Admite extensiones siempre que las funciones range_begin y range_end estén correctamente. Pero, el ejemplo en boost doc usa std :: string :: iterator como tipo de retorno, mientras que lo que necesito es una clase de iterador genérico y aún no pude descubrir cómo hacerlo.

std::vector<MyContainer*> containers;
for(int i=0 ; i<containers.size() ; i++){
  BOOST_FOREACH(MyObject obj, *(containers[i])) {
    std::cout << obj.myInt << std::endl;
  }
}

Creo que puedo definir mi propia clase de iterador, luego cada clase que extiende BaseContainer debería definir su propio iterador extendiendo ese iterador básico. Sin embargo, preferiría usar iteradores estándar (stl o boost) para admitir esta estructura, en lugar de escribir mis propios iteradores. Creo que este enfoque funcionará, pero estoy abierto a comentarios sobre su eficiencia.

¿Existe un enfoque factible que pueda resolver este problema con elegancia? ¿O me estoy perdiendo un punto simple que puede resolver este problema sin ningún dolor?

Una pregunta similar se puede encontraraquí, pero las soluciones propuestas parecen un poco complejas para mis necesidades, y los requisitos difieren hasta donde puedo entender.