gibts ne möglichkeit auf den Next bzw. PRev Zeiger eines Listenelemts der std:list zuzugriefen?

Und wieso ist der std:list<>::iterator so langsam??

Wenn ich jedem Objekt meiner Liste einen Zeiger auf das nächste/davorliegen Objekt setze, und dann mit den Zeiger iterier... ist die iteration um den faktor 3000 schneller! Aber wieso so ein krasser performance unterschied?

Hier der Code:

#include "stdafx.h"

struct TEST{

    double m_dDuration;
    TEST* Prev;
	TEST* Next;

    double Time(){
        if(Prev==NULL)
            return 0;
        else
            return Prev->Time()+m_dDuration;
    }
};    

int _tmain(int argc, _TCHAR* argv[]){

	std::list<TEST> LISTE;

    for(int i=0; i<1000; i++){

        TEST o;
         if(LISTE.empty()){
            o.m_dDuration=0;
            o.Prev=NULL;
			o.Next=NULL;
			LISTE.push_back(o);
        }
        else{
            o.m_dDuration=10;
			LISTE.push_back(o);
			(--(--LISTE.end()))->Next= &LISTE.back();//(--LISTE.end());
			(--LISTE.end())->Prev= &((--(--LISTE.end()))._Ptr->_Myval);
        }

    }

	//ITERATOR
	long lDiff= timeGetTime();
	for(int l=0; l< 1000; l++){
		double Sum=0;
		for(std::list<TEST>::iterator it= LISTE.begin(); it!= LISTE.end() ; it++)
			Sum+=it->m_dDuration;

	}
	lDiff= timeGetTime()- lDiff;

	//ZEIGER
	lDiff= timeGetTime();
	for(int l=0; l< 1000; l++){
		double Sum=0;
		for(TEST* p= &LISTE.front(); p!= NULL  ; p= p->Next)
			Sum+=p->m_dDuration;
	}
	lDiff= timeGetTime()- lDiff;
	return 0;
}

Hab ich einen Denkfehler drin, oder ist der unterschied wierklich so krass?

Schade kanns in Release nich testen, timeGetTime(); unaufgelöstes Symbol.. wieso?

#ifdef _MSC_VER
#	define _SECURE_SCL 0 // disables range checks for std:: containers.
#endif

Vor den #includes.

Gruß
Don06

Schade kanns in Release nich testen, timeGetTime(); unaufgelöstes Symbol.. wieso?

Im Release musst du evtl nochmal die lib einbinden

for(std::list<Test>::iterator it = liste.begin(); it != liste.end(); ++it)
  sum += it->m_dDuration;

Und Variablen ganz groß zu schreiben, klingt - wie hier im Forum - auch nach Schreien oder aber nach Makros -)

template <class DataType>
class List
{
	struct ListNode
	{
		ListNode(ListNode* nxt, ListNode* prv, DataType* dat)
			: next(nxt), prev(prv), data(dat) 
		{ }

		DataType* data;

		ListNode* next;
		ListNode* prev;
	};
	typedef ListNode Node;

public:
	typedef Node* iterator;

	List() : startNode(0), lastNode(0)
	{ }

	~List()
	{
		clear();
	}

	void clear()
	{
		iterator next;
		for (iterator iter = startNode; iter != 0; iter = next)
		{
			next = iter->next;
			delete iter->data;
			delete iter;
		}
		startNode = 0;
		lastNode  = 0;
	}

	void push_back(const DataType& data)
	{
		DataType* pData = new DataType(data);
		if (startNode == 0)
		{
			startNode = new Node(0, 0, pData);
			lastNode  = startNode;
		}
		else
		{
			Node* newNode = new Node(0, lastNode, pData);
			lastNode->next = newNode;
			lastNode = newNode;
		}
	}

	Node* startNode;
	Node* lastNode;

private:
	List(const List&);
	List& operator =(const List&);
};

Dazu mein "Benchmark":

#ifdef _MSC_VER
#	define _SCL_SECURE 0
#endif

#include <list>
#include <iostream>

#include <windows.h>

#include "DonsList.h"

int main()
{
	List<unsigned int>      primitiveList;
	std::list<unsigned int> standardList;

	DWORD startTime;
	DWORD endTime;

	startTime = GetTickCount();
	for (unsigned int i = 0; i < 5000000; ++i)
		primitiveList.push_back(i);
	endTime = GetTickCount();
	std::cout << "DonsList: Time to fill: " << endTime - startTime << std::endl;

	startTime = GetTickCount();
	for (unsigned int i = 0; i < 5000000; ++i)
		standardList.push_back(i);
	endTime = GetTickCount();
	std::cout << "std::list: Time to fill: " << endTime - startTime << std::endl;

	startTime = GetTickCount();
	for (List<unsigned int>::iterator iter = primitiveList.startNode; 
		iter != primitiveList.lastNode; iter = iter->next)
		(*(iter->data)) = 1;
	endTime = GetTickCount();
	std::cout << "DonsList: Iteration time: " << endTime - startTime << std::endl;

	startTime = GetTickCount();
	for (std::list<unsigned int>::iterator iter = standardList.begin();
		iter != standardList.end(); ++iter)
		(*iter) = 1;
	endTime = GetTickCount();
	std::cout << "std::list: Iteration time: " << endTime - startTime << std::endl;

	return 0;
}

Die std::list ist meiner Variante sowohl bei der Füllzeit als auch bei der Iterationszeit (weit) überlegen:

DonsList:  Time to fill:   3484
std::list: Time to fill:   1797
DonsList:  Iteration time:  110
std::list: Iteration time:   78

Im Debug Modus siehts dann wieder anders aus:

DonsList:  Time to fill:  16688
std::list: Time to fill:  19609
DonsList:  Iteration time:  297
std::list: Iteration time: 6813

Allerdings macht std::list bestimmt sinnvolle Überprüfungen bei der Iteration, die in meiner Variante ja nicht enthalten sind.

Gruß
Don06

Gibts keine mögichkeit auch im debug mode mit der release geschwindigkeit der liste zu arbeiten?

sehr gut.. danke für deine hilfe.. dann werd ich doch den std::list verwenden;)

Gibts keine mögichkeit auch im debug mode mit der release geschwindigkeit der liste zu arbeiten?

Du verlierst doch die Vorteile des Debugmodus, wenn du das tun würdest. Es geht sicherlich, indem du irgendein #define umänderst, aber im Prinzip kann man dann auch gleich in den Releasemodus wechseln.
In VC++ kann man imho eigene Buildoptionen erstellen. Dort könntest du ja so eine Art Hybridmodel entwickeln, allerdings sehe ich den Sinn darin bisher nicht.

Gruß
Don06

Da stellt sich die frage, welche unterschiede es im relese mode zum debug mode gibt? DAs Programm kann ja im debug mode ohne fehler laufen, aber im release können ja unerwartet fehler auftreten.. oder? was macht der compiler das genau..

Hab mal gehört das im debug mode Boolean automatisch auf false intialisert werden vom compiler.. im release mode sind sie undefiniert?

Da stellt sich die frage, welche unterschiede es im relese mode zum debug mode gibt? DAs Programm kann ja im debug mode ohne fehler laufen, aber im release können ja unerwartet fehler auftreten.. oder? was macht der compiler das genau..

Afaik gibt es im Debug-Modus einfach eine Menge mehr Sicherheitsabfragen. Wenn du dir mit new Speicher holst und ein kleines Stückchen darüber hinausschreibst, wird das im Debug gemeldet, im Release bemerkt man es meistens nicht. Von daher sollte man eigentlich nur für das fertige Produkt oder gelegentliche (Performance-)Tests den Releasemodus einschalten.

und das mit dem bool weiß ich nicht, lässt sich aber sicherlich relativ einfach herausfinden

oder so?

Wenn debug aktiviert ist , soll er für list debug deaktieren und danach wieder aktiveren ! das passt ihm wohl nich

Naja der compiler meint wenn einige sachen im debug mode sind und andere nicht gibts evtl. probleme.. schadE;)

Zum Initialisieren der Variablen: VC++ initialisiert im Debugmodus _alle_ Variablen, sogar den Speicher, den man auf dem Heap alloziert. Aber du solltest eh nie uninitialisierte Variablen verwenden! Wenn man also ordentlich programmiert kommen solche Probleme, wie "es funktioniert im Debugmodus aber nicht im Releasemodus" gar nicht vor.

Gruß
Don06

Im Releasemode eliminiert der Compiler dagegen viel an Code wenn er nicht nötig ist, verschiebt Codeteile etc. All das führt dazu dass man das Programm kaum noch vernünftig debuggen kann.

p.S.: die meisten Compiler erzeugen im Debugmodus sogar Code der dafür sorgen soll dass gewisse Fehler auftreten. z.B. werden Variablen die nicht initialisiert wurden mit bestimmten einfach zu erkennenden Mustern gefüllt (statt das zu beinhalten was auch immer vorher an der Speicherstelle stand die jetzt für die Variable verwendet wird). Oder es werden zusätzliche Bereiche vor und hinter einem dynamisch angeforderten Speicherblock mit bestimmten Mustern gefüllt die dann beim Freigeben wieder überprüft werden, damit man draufkommt wenn mehr Speicher geschrieben wurde als man angefordert hat.

Viel lieferen ihre Software im debug modus aus... weil sie angst haben das die software im release nich so funktioniert wie im Debug mode

Hätte ich noch nie gehört, ich vermute du schreibst Schwachsinn.

lolz schrieb:

Man sollte beim programmieren auch regelmäßig die Release-Version kompilieren und testen. Wer das vernachlässigt hat es später unnötig schwer Fehler zu finden.

Das kommt drauf an wie man programmiert würde ich sagen. Ich hatte in letzter Zeit (2-3 Jahre) kaum mehr Fehler die schwer zu finden waren, und nix dabei was sich nur im Release Mode manifestiert hätte.