for(std::list<CAllocStruct::CAllocNode*>::iterator it = it_New; it!= m_pMyBase->m_lList.begin();){

		--it;
.
.   //Mit inhalt von it arbeiten
.

}

gibts da ne bessere variante?

for(--(std::list<CAllocStruct::CAllocNode*>::iterator it = it_New); it!= m_pMyBase->m_lList.begin(); --it)
// müsste eigentlich auch gehen:
for(std::list<CAllocStruct::CAllocNode*>::iterator it = (it_New - 1); it!= m_pMyBase->m_lList.begin(); --it)

schöner find ich die version allerdings nicht ^^

for ( list_type::reverse_iterator it( list.rbegin() ); it != list.rend(); ++it )
{
	std::cout << ( *it ) << std::endl;
}

for(--(std::listCAllocStruct::CAllocNode*::iterator it = it_New); it!= m_pMyBase->m_lList.begin(); --it)

ist sowas möglich#?

for(--(std::listCAllocStruct::CAllocNode*::iterator it = it_New); it!= m_pMyBase->m_lList.begin(); --it)

Nein. Was spricht deiner Meinung gegen den reverse_iterator?

ist sowas möglich#?

for(--(std::listCAllocStruct::CAllocNode*::iterator it = it_New); it!= m_pMyBase->m_lList.begin(); --it)

ich sagte ja, es sei fehlerhaft der fehler ist aber primär, dass der iterator so möglicherweise nicht korrekt überprüft wird, nämlich genau dann, wenn it_New bereits auf m_lList.begin() zeigt.

das sekundäre problem ist, dass durch die klammerung die deklaration verschwindet. grundsätzlich geht sowas aber schon.

std::list<CAllocStruct::CAllocNode*>::iterator it;
for(--(it = it_New); it!= m_pMyBase->m_lList.begin(); --it)

der primäre fehler ist natürlich weiterhin enthalten.

folgende Schleife soll vom Listen ende bis zur Position (it_New) rückwärte die liste travesieren, dabei soll die forschleife nich bei it_New, sonder eine einheit davor beginnen. bisher so gelöst:

for(std::list<CAllocStruct::CAllocNode*>::iterator it = it_New; it!= m_pMyBase->m_lList.begin();){
		
		--it;
.   //Mit inhalt von it arbeiten
}

gibts da ne bessere variante?

for( std::list<CAllocStruct::CAllocNode*>::reverse_iterator it( it_New ) // it zeigt hier auf eine Position VOR it_New
        ; it != m_pMyBase->m_lList.rend(); ++it )
    {
        // mit *it arbeiten

Gruß
Werner

folgende Schleife soll vom Listen ende bis zur Position (it_New) rückwärte die liste travesieren, dabei soll die forschleife nich bei it_New, sonder eine einheit davor beginnen.

Also entweder ich bin jetzt völlig bekloppt, oder deine Beschreibung und dein Code passen überhaupt nicht zusammen. Du schreibst: "vom Listen ende", das wäre list.end(). "bis zur Position (it_New) rückwärte" impliziert, dass it_New *vor* list.end() liegt und damit den Endpunkt der Traversierung markiert. Damit ist "dabei soll die forschleife nich bei it_New, sonder eine einheit davor beginnen" unlogisch, da du damit einen Startpunkt außerhalb des zu traversierenden Bereichs hättest.

Dein Code hingegen sagt: Von it_new rückwärts bis list.begin(). Damit traversierst du also nicht "vom Listen ende" sondern von it_new und nicht "bis zur Position (it_New) rückwärte" sondern bis list.begin().

Mal davon abgesehen: Wie bereits gesagt wurde, gibt es zum rückwärts-traversieren von STL-Containern extra die reverse-Iteratoren. Die Alternative wäre die kanonische Schleife fürs Rückwärtslaufen (benutzt man meist, wenn man mit unsigned-Werten arbeitet)
Zur Erinnerung:

iterator x = list.end();
while (x != list.begin()) {
   --x;
   // do something with x
}

Für deinen Fall, so ich ihn denn richtig verstehe:

iterator x = it_New;
while (x != list.begin()) {
   --x;
   // do something with x
}

Der Unterschied zu deiner Schleife ist übrigens, dass diese hier auch bei einer leeren Liste funktioniert.