Iterateur perso

Bonjour,
Me revoilà avec ma classe Triplet, dans ce genre (pour l'exemple) :

struct Triplet
{
int Values[ 3 ];

Triplet( int A, int B, int C )
{
this->Values[ 0 ] = A;
this->Values[ 1 ] = B;
this->Values[ 2 ] = C;
}
};

J'ai un vector de Triplet, je souhaiterais pouvoir lui appliquer des
algorithm tels que max_element, etc... sur
une dimension données des triplets (index 0, 1 ou 2). Quelle est la
meilleure solution ?
J'ai d'abord pensé à un functor d'accès spécial fourni comme comparateur et
l'utilisation de bind1st pour lui
donner la dimension à manipuler, mais je me suis tourné vers un wrapper
d'iterator :

template<typename T>
template<typename T>
class iter_wrapper
{
public:
iter_wrapper( const T & Iter, int Index ):
iter( Iter ), index( Index ) {}

public:
typedef const iter_wrapper<T> const_iterator;

int operator*() const
{
return this->iter->Values[ this->index ];
}

const_iterator& operator++()
{
++this->iter;
return *this;
}

bool operator!=( const const_iterator & _Right ) const
{
return this->iter != _Right.iter;
}

private:
T iter;
int index;
};

template<typename T>
inline iter_wrapper<T> select_index( const T & Iter, int Index )
{
return iter_wrapper<T>( Iter, Index );
}

int main()
{
std::vector<Triplet> v;
v.push_back( Triplet( 0, 1, 0 ) );
v.push_back( Triplet( 0, 2, 0 ) );
v.push_back( Triplet( 0, 3, 0 ) );


int max_b = *std::max_element(
select_index( v.begin(), 1 ),
select_index( v.end(), 1 ) );
}

Qu'en pensez-vous ?
Merci pour votre aide.

--
Aurélien REGAT-BARREL