Class design with tightly bound iterator

I am working on a class design to contain the indices of triangle lists for
body parts. This is for 3d modeling. As as start I have:

class PartTriangles
{
public:
    PartTriangels( const std::string& Name ): Name( Name ) {}
private:
    std::string Name;
    std::set<size_t> Triangles;
    std::vector<PartTriangles> Connections;
};

which may (probably will) change and a lot of things added. Anyway... the
reason I am designing this class is I need to keep a list of the indices for
a model for each body part so I can animate them, meaning I need to get some
type of list of what triangles are in, for instance, the right leg. My
thought was that this ... three type list... would start with the torso
"torso". Whoulc would have in it's vector 5 connections, head, right
bicept, left bicept, right upper leg, left upper leg. So in this way every
triangle would be list listed somewhere to contain the entire body, but only
once. Now, the situation is, I need to be able to get a list of things that
are in, say, the right leg, which would contain the upper leg, lower leg and
foot. So interators came to mind. So this is what I am planning on
developing:

someinteratortype it = MyBody("right upper leg");
It should be fairly easy for PartTriangles to return an iterator pointing to
it's std::set for the beginning of the upper leg. However, it would not
actually be in the instance of MyBody, which would have the set for Torso,
but in MyBody's vector of PartTriangles where the name is "right upper leg".
Also is the complication of .end() There are 5 end()'s, one for head, one
for right hand pinky (if I go as far as fingers), left hand pinkie, right
foot, etc..

In addition, looking at an implementation of a custom iterator, it's
increment is simply:
 custom_iterator& operator++()
{
   // preincrement
   ++m_Ptr;
   return (*this);
}
custom_iterator operator++(int)
{
   // postincrement
   custom_iterator _Tmp = *this;
   ++*this;
   return (_Tmp);
}

m_Ptr is
_Ty *m_Ptr;
in a template.

It seems to me that my iterator would have to store more information than a
single pointer especially for increment. Consider the case where I am
iteratiing over the right upper leg and get to the end of PartTriangle's
set, I would then want an increment to step into Connection's into it's
entries sets, etc... Of course, after it went through the first set, it may
have to back out to do the next part of the vector, looking like I have some
type of recursion taking place.

Anyone have familiarity with these types of iterators, or am I trying to
make an iterator do something it's not designed for?

I'm open to any and all suggestions.