Also ich habe bisher nicht die gesamte Diskussion verfolgt, möchte aber ein paar allgemeine Worte sagen: Es ist oftmals besser, anstatt sich in irgendwelchen Kleinigkeiten zu verstricken, sich zu überlegen, was die effizienteste Methode beim Programmdesign, und nicht nur bei der Implementierung ist.
Aber selbst bei relativ simplen Sachen, kann man oftmals viel optimieren, Beispiel for-Schleife:
For-Schleifen werden häufig benutzt, aber dennoch wird dabei oft viel Overhead produziert. Ein Beispiel:
Code:
for(std::list<myclass>::iterator iter = lis.begin(); iter != lis.end(); iter++)
{
//...
}
Sieht zunächst wie eine gewöhnliche Schleife aus (und ist auch eine), dennoch verschenkt man hier grundlos Rechenleistung.
1.
lis.end()
Bei jedem Schleifendurchlauf wird dies neu berechnet, obwohl sich der Wert nicht ändern wird (wenn er es täte und innerhalb der Schleife z. B. ein Objekt in den Vektor eingefügt würde, so bestünde die Möglichkeit, dass alle Iteratoren ungültig werden, und es dadurch zu einem Laufzeitfehler kommt).
2.
iter++
Hier wird immer ein temporäres Objekt erzeugt, dass aber nie benutzt wird.
Ein Postinkrementoperator arbeitet in etwa so (Pseudo-Code):
Code:
old(obj);
++obj;
return old;
Der Compiler kann dies in diesem Fall sehr wahrscheinlich nicht optimieren. Dies wäre nur der Fall, wenn es sich a) um einen eingebauten oder Standard-Typ handelt. Es wäre auch noch möglich, wenn man beim Postinkrementoperator ähnlich wie oben den Preinkrementoperator benutzt und dies zusätzlich noch inline macht, allerdings ist diese Lösung a) aufwendig und b) implementationsabhäbhängig.
Hier die verbesserte Version:
Code:
std::list<myclass>::iterator end = lis.end();
for(std::list<myclass>::iterator iter = lis.begin(); iter != end; ++iter)
{
//...
}
Wir können es nicht für dich implementieren, das musst du schon selber machen.
