mit Eurer Hilfe habe ich ja vor kurzem meinen eigenen Container mit einen Iterator ergänzt. Das tut auch alles wunderbar. Nun will ich daher ein wenig aufräumen und andere Container auf diesen zurückführen. Dazu fehlen mir aber ein paar operatoren und Methoden. Nun bin ich am basteln und bekomme einen Fehler, wo ich gar nicht weiß, was die mir sagen will. Daher die Frage an Euch: was ist da den falsch?

Zum Kontext: Mein Container ist List<T> und ich will PairQueue als Wrapper drum herum bauen. DetectionTimer ist nen Timer, der in der PairQueue unter einer PeerID als Schlüssel gespeichert wird.

In der Methode:

template <typename S, typename T>
        T
        PairQueue<S, T>::find(const S & key) const {
            typename STPairList::iterator it;
            it = std::find_if(queue.begin(),
                    queue.end(),
                    STPairListFunctor(key));
            if (it == queue.end()) {
                return NULL;
            }
            return (it->second); 
        }

Kommt es in der Zeile it = std::find_if(queue.begin() zu folgenen Fehler:

PairQueue.h:175: error: no match for ‘operator=’ in ‘it = std::find_if [with _IIter = List<std::pair<PeerID, DetectionTimer*> >::Iterator<const std::pair<PeerID, DetectionTimer*> >, _Predicate = PairQueue<PeerID, DetectionTimer*>::STPairListFunctor](((const PairQueue<PeerID, DetectionTimer*>*)this)->PairQueue<PeerID, DetectionTimer*>::queue::List<T>::begin [with T = std::pair<PeerID, DetectionTimer*>](), ((const PairQueue<PeerID, DetectionTimer*>*)this)->PairQueue<PeerID, DetectionTimer*>::queue::List<T>::end [with T = std::pair<PeerID, DetectionTimer*>](), PairQueue<PeerID, DetectionTimer*>::STPairListFunctor(((const PeerID&)((const PeerID*)key))))’

Die Variable queue ist vom Typ List<Pair>, welche von der PairQueue genutzt wird, wobei ein Pair halt nen Standard_pair von PeerID und DetectionTimer* ist.

Jemand nen Tip???

Danke schon einmal.

`

h:175: error: no match for ‘operator=’ in ‘it = std::find_if [with _IIter =

List<std::pair<PeerID, DetectionTimer*> >::Iterator<const std::pair<PeerID,

DetectionTimer*> >, _Predicate = PairQueue<PeerID,

DetectionTimer*>::STPairListFunctor](((const PairQueue<PeerID,

DetectionTimer*>*)this)->PairQueue<PeerID,

DetectionTimer*>::queue::List<T>::begin [with T = std::pair<PeerID,

DetectionTimer*>](), ((const PairQueue<PeerID, DetectionTimer*>*)this)-

PairQueue<PeerID, DetectionTimer*>::queue::List<T>::end [with T =

std::pair<PeerID, DetectionTimer*>](), PairQueue<PeerID,

DetectionTimer*>::STPairListFunctor(((const PeerID&)((const PeerID*)key))))’

`

den operator= habe ich so:

template <typename L>
            class Iterator : public std::iterator<std::forward_iterator_tag, L> {

                L * pos;

                friend class List<T>;

                explicit Iterator(L * aPos);

            public:
...
Iterator<L> operator=(const Iterator<L> & other);
...
};

Ich vermute das reicht wohl nicht. liegt es am forward_iterator????

Poste den ganzen Code auf Codepad.org o.ä. und verlinke es bitte. So ist es extrem anstrengend weitere Aussagen zu treffen.

no match for ‘operator=’ in 
‘it = std::find_if [with _IIter = List<std::pair<PeerID, DetectionTimer*> >::Iterator<const std::pair<PeerID, DetectionTimer*> >, _Predicate = PairQueue<PeerID, DetectionTimer*>::STPairListFunctor]
(((const PairQueue<PeerID, DetectionTimer*>*)this)->PairQueue<PeerID, DetectionTimer*>::queue::List<T>::begin [with T = std::pair<PeerID, DetectionTimer*>](), 
 ((const PairQueue<PeerID, DetectionTimer*>*)this)->PairQueue<PeerID, DetectionTimer*>::queue::List<T>::end   [with T = std::pair<PeerID, DetectionTimer*>](), 
 PairQueue<PeerID, DetectionTimer*>::STPairListFunctor(((const PeerID&)((const PeerID*)key))))’

STPairList::iterator ist folglich nicht dasselbe wie List<std::pair<PeerID, DetectionTimer*> >::Iterator<const std::pair<PeerID, DetectionTimer*> .
Angenommen, STPairList ist ein Typedef für List<std::pair<PeerID, DetectionTimer*> > -
Dann ist iterator ein Typedef in STPairList , und dieses Typedef verweist nicht auf die Spezialisierung Iterator<const std::pair<PeerID, DetectionTimer*>> .

Meine Theorie ist folgende:** queue ist const **, daher ist der Rückgabewert von begin() / end() eine Spezialisierung des Iterator -Templates mit Zeiger auf const .
Also:
Typ von it ist Iterator<std::pair<PeerID, DetectionTimer*>>
Typ von queue.begin() ist Iterator<const std::pair<PeerID, DetectionTimer*>>

Edit: Schließende Klammer vergessen... doofe Template-Fehlermeldungen..

hier also der gewünschte code in lang.

Zunächst die List.h:
http://codepad.org/c0ZmouJG

und die PairQueue.h:
http://codepad.org/qur0oCaR

Der Itertator ist nen Template, weil List nen Template ist.

Wenn ich den STPairListFunctor (was für nen mistding, aber lamda ausdrücke gehen hier leider noch nicht ) um einen Konstruktor:

STPairListFunctor(const STPair & pair) { orig = pair.first; }

Ändert dies leider nix. Er bleibt bei:

PairQueue.h:179: error: no match for ‘operator=’ in ‘it = std::find_if 
[with _IIter = List<std::pair<PeerID, DetectionTimer*> >::Iterator<const std::pair<PeerID, DetectionTimer*> >, 
_Predicate = PairQueue<PeerID, DetectionTimer*>::STPairListFunctor]
(
((const PairQueue<PeerID, DetectionTimer*>*)this)->PairQueue<PeerID, DetectionTimer*>::queue.List<T>::begin [with T = std::pair<PeerID, DetectionTimer*>] (), 
((const PairQueue<PeerID, DetectionTimer*>*)this)->PairQueue<PeerID, DetectionTimer*>::queue.List<T>::end   [with T = std::pair<PeerID, DetectionTimer*>] (), 
PairQueue<PeerID, DetectionTimer*>::STPairListFunctor(((const PeerID&)((const PeerID*)key)))
)’

Das const PairQueue sehe ich, verstehs aber nicht, auch gerade nicht mit den Erklärungen von Arcoth.

Aber ein riesen Dank für Eure mühe Jungs!

der sven_

no match for ‘operator=’ in ‘it = std::find_if(_IIter, _IIter, _Predicate) 
      [with _IIter = List<std::pair<PeerID, DetectionTimer*> >::Iterator<std::pair<PeerID, DetectionTimer*> >, 
        _Predicate = PairQueue<PeerID, DetectionTimer*>::STPairListFunctor](List<T>::end() [with T = std::pair<PeerID, DetectionTimer*>](), PairQueue<PeerID, DetectionTimer*>::STPairListFunctor(((const PeerID&)((const PeerID*)key))))’

candidates are: List<T>::Iterator<L> List<T>::Iterator<L>::operator=(List<T>::Iterator<L>&) [with L = std::pair<PeerID, DetectionTimer*>, T = std::pair<PeerID, DetectionTimer*>]

wie muß die signatur von operator= sein?? jemand nen tip?

typename STPairList::const_iterator it;