C ++: шаблон стратегии + итератор для каждой стратегии

Скажем, у меня есть шаблон стратегии с двумя классами, реализующими стратегию, где у каждого есть некоторый набор значений, но значения хранятся в разных контейнерах, например, в векторе и в списке.

Я хотел бы иметь итератор, позволяющий мне просматривать каждое из значений в каждом классе.
Я также хотел бы иметь возможность использовать стандартный способ итератора, что означает переход по значениям следующим образом:

Strategy s = //Some initialization.
Strategy :: iterator it;
for (it = s.begin(); it != s.end() ; ++it){
//Do something with *it.
}

на данный момент единственное решение, которое у меня есть, это: другой шаблон стратегии, в котором класс Strategy имеет контекстный итератор. у другого StrategyIterator и у каждого «класса реализации стратегии» есть свой собственный класс — selfIterator: public StrategyIterator.

но это кажется довольно хлопотным, и, может быть, у кого-то больше творчества, чем у меня.
Так что я бы очень признателен за некоторые идеи :), спасибо!

Это для программы, которая манипулирует полиномами, где стратегия представляет собой представление полинома, одна с вектором, а другая стратегия со списком.

Вот также файл H программы, для которой я хочу использовать его:

#include <iostream>
#include <vector>
#include <list>

using namespace std;

#ifndef MYPOLY_H
#define MYPOLY_H

class PolyRep;
class RegIterator;

typedef enum Poly
{
REG_POLY = 1, SPARSE_POLY = 2
};

/* =============================================================================
* MyPoly class.
* =============================================================================*/

class MyPoly
{
public:

MyPoly(double arr[], unsigned int arrSize);

MyPoly(double num);

MyPoly(double X[], double Y[], int arrSize);

MyPoly(string sPoly);

~MyPoly();

string toString();

double evaluate(double x) const;

MyPoly derive(int n);

MyPoly & operator =(const MyPoly &rhs);

MyPoly & operator +=(const MyPoly &rhs);

MyPoly & operator -=(const MyPoly &rhs);

MyPoly & operator *=(const MyPoly &rhs);

MyPoly operator +(const MyPoly& other);

MyPoly operator -(const MyPoly& other);

MyPoly operator *(const MyPoly& other);

bool operator ==(const MyPoly& b) const;

MyPoly operator -() const;private:
PolyRep * _poly;};

/* =============================================================================
* PolyRep class.
* =============================================================================*/

class PolyRep
{
public:

virtual double evaluate(const double &x) const = 0;

//virtual iterator begin () = 0;
//virtual PolyRep * derive(int n) = 0;protected:
int _degree;
};

/* =============================================================================
* RegPoly class.
* =============================================================================*/class RegPoly : public PolyRep
{
public:
RegPoly(double arr[], int degree);
~RegPoly();
double evaluate(const double &x) const;

private:
vector <double> _values;
};

/* =============================================================================
* SparsePoly class.
* =============================================================================*/

class SparsePoly : public PolyRep
{
public:
SparsePoly(double arr[], int degree);
~SparsePoly();
double evaluate(const double &x) const;

private:

/*A class to represent a node in the SaprsePoly list.*/
class SparseNode
{
public:
SparseNode(int n = 0, double value = 0);
int getN() const;
double getValue() const;
private:
int _n;
double _value;
};
/*End of sparse node class.*/

list <SparseNode*> _values;
};
#endif  /* MYPOLY_H */