Hi,
folgendes, ich hätte gerne eine Liste mit Funktoren(boost.function), die als Parameter einen Iterator dieser Liste nehmen. Das Problem ist, dass ich für den Iteratortyp den Typ der Liste kennen müsste, den ich aber nicht kennen kann, da der Typ der Liste vom Iteratortypen abhängt.
Wie kann ich das lösen?

Ich bin mir zwar nicht so ganz sicher, ob ich Dein Problem richtig verstanden habe, aber ich denke, dass Dir evtl. boost.range helfen hönnte.

Wie kann ich das lösen?

Keine Ahnung, deine Problembeschreibung ist sehr duerftig.

Verstehe ich das richtig, daß du sowas hier machen möchtest (wenn es denn ginge)?

typedef std::list<boost::function<void (MyList::iterator)> > MyList;

class MyIterator : public boost::bidirectional_iterator_helper<MyIterator,
                 boost::function<void (MyIterator)> > //liefert Operatoren und standardkonforme Iterator-typedefs
{
public: 
  typedef std::list<boost::function<void (MyIterator)> >::iterator list_iterator;

  MyIterator(list_iterator it = list_iterator()) : it_(it) {}
  reference operator*() {return *it_;}
  MyIterator& operator++() {++it_; return *this;}
  MyIterator& operator--() {--it_; return *this;}

  operator list_iterator() {return it_;}

  friend bool operator== (MyIterator const& lhs, MyIterator const& rhs) {return lhs.it_ == rhs.it_}

private:
  list_iterator it_;
};

Voraussetzung ist, dass für boost::function<void (MyIterator)> die Klasse MyIterator noch nicht vollständig definiert sein muss.
Sollte das der Fall sein könntest du schauen ob du daraus ein boost::function<void (MyIterator&)> machen kannst und in den Funktionen den iterator entsprechend kopierst.

struct MyIteratorWrapper;

typedef boost::function<void (MyIteratorWrapper const*)> Functor;

typedef std::list<Functor> FunctorList;

struct MyIteratorWrapper
{
    explicit MyIteratorWrapper(FunctorList::iterator const& it) : m_it(it) {}
    FunctorList::iterator m_it;
};

void FunctionA(MyIteratorWrapper const* itw)
{
    FunctorList::iterator const& it = itw->m_it;
}

void Test()
{
    FunctorList l;
    l.push_back(boost::bind(FunctionA, _1));

    MyIteratorWrapper itw(l.begin());
    l.front()(&itw);
}

Allerdings finde ich das alles ziemlich unschön. Und ich kann mir auch nicht vorstellen wo man sowas jetzt brauchen würde.