ich würde gerne eine doppelt verkettete LIste benutzen. Wie wird denn verfahren wenn ein element umgehängt werden muss z.B. von position 4 auf position 0?
Wird dann teuer umhergespeichert oder geht das schnell weil nur pointer umgehängt werden?

Kann man auch auf willkürliche Positionen einfügen udn nicht nur am anfang oder ende?

ich habe im Moment ein iterator problem:

warum kann ich folgende schleife nicht kompilieren:

for(std::list< std::pair< ND, MY_DATA<T> > >::iterator pos = my_lst.begin(); pos != my_lst.end(); pos++)

ND ist einfach nur ein umbenannter Typ, und MY_DATA ein templatebasiertes struct...

Mein Compiler schreit mit
error: expected `;' before 'pos'

for(typename std::list< std::pair< ND, MY_DATA<T> > >::iterator pos = my_lst.begin(); pos != my_lst.end(); pos++)

Hoffe das funzt... sonst wirds peinlich für mich.

wenn ich ein element irgendwo in der mitte ganz an den anfang stellen will und die restlichen einfach nur um eins weiterschieben will - muss ich dazu wirklich erst die daten des elements extrahieren, dann das element löschen und dann vorne einfügen?

oder gibt es was eleganteres wie eine art make_first ?

Aber das sollte von der Performance her nicht schlimm sein...

template <class T>  bool 
AAA<T>::In_AAA(const Key key)
{      
    struct DATA<T> data;
    typename std::list< std::pair< Key, DATA<T> > >::iterator pos;

    for(pos = m_c.begin(); pos != m_c.end(); ++pos) 
    {
        data = *pos;
        if (key == data.first)
        {
            m_found = *pos;
            return true;    
        }
    }

    return false;
}

warum kann ich denn nicht den gefundenen iterator zuweisen? Geht das nicht dass ich praktisch das element zuweise wo mir *pos hinzeigt?
oder müsste ich eine vollständige Kopie anlegen?