Hier ist ein Benchmark für den Fall, dass sich Inkrementoperatoren in verschiedenen Übersetzungseinheiten befinden. Compiler mit g ++ 4.5.
Ignorieren Sie vorerst die Stilprobleme
// a.cc
#include <ctime>
#include <array>
class Something {
public:
Something& operator++();
Something operator++(int);
private:
std::array<int,PACKET_SIZE> data;
};
int main () {
Something s;
for (int i=0; i<1024*1024*30; ++i) ++s; // warm up
std::clock_t a = clock();
for (int i=0; i<1024*1024*30; ++i) ++s;
a = clock() - a;
for (int i=0; i<1024*1024*30; ++i) s++; // warm up
std::clock_t b = clock();
for (int i=0; i<1024*1024*30; ++i) s++;
b = clock() - b;
std::cout << "a=" << (a/double(CLOCKS_PER_SEC))
<< ", b=" << (b/double(CLOCKS_PER_SEC)) << '\n';
return 0;
}
O (n) Inkrement
Prüfung
// b.cc
#include <array>
class Something {
public:
Something& operator++();
Something operator++(int);
private:
std::array<int,PACKET_SIZE> data;
};
Something& Something::operator++()
{
for (auto it=data.begin(), end=data.end(); it!=end; ++it)
++*it;
return *this;
}
Something Something::operator++(int)
{
Something ret = *this;
++*this;
return ret;
}
Ergebnisse
Ergebnisse (Zeitangaben in Sekunden) mit g ++ 4.5 auf einer virtuellen Maschine:
Flags (--std=c++0x) ++i i++
-DPACKET_SIZE=50 -O1 1.70 2.39
-DPACKET_SIZE=50 -O3 0.59 1.00
-DPACKET_SIZE=500 -O1 10.51 13.28
-DPACKET_SIZE=500 -O3 4.28 6.82
O (1) Inkrement
Prüfung
Nehmen wir nun die folgende Datei:
// c.cc
#include <array>
class Something {
public:
Something& operator++();
Something operator++(int);
private:
std::array<int,PACKET_SIZE> data;
};
Something& Something::operator++()
{
return *this;
}
Something Something::operator++(int)
{
Something ret = *this;
++*this;
return ret;
}
Es macht nichts in der Inkrementierung. Dies simuliert den Fall, dass die Inkrementierung eine konstante Komplexität aufweist.
Ergebnisse
Die Ergebnisse variieren jetzt extrem:
Flags (--std=c++0x) ++i i++
-DPACKET_SIZE=50 -O1 0.05 0.74
-DPACKET_SIZE=50 -O3 0.08 0.97
-DPACKET_SIZE=500 -O1 0.05 2.79
-DPACKET_SIZE=500 -O3 0.08 2.18
-DPACKET_SIZE=5000 -O3 0.07 21.90
Fazit
Leistungsmäßig
Wenn Sie den vorherigen Wert nicht benötigen, machen Sie es sich zur Gewohnheit, das Vorinkrement zu verwenden. Seien Sie auch mit eingebauten Typen konsistent, Sie werden sich daran gewöhnen und laufen nicht Gefahr, unnötige Leistungseinbußen zu erleiden, wenn Sie jemals einen eingebauten Typ durch einen benutzerdefinierten Typ ersetzen.
Semantisch
i++sagt increment i, I am interested in the previous value, though.++isagt increment i, I am interested in the current valueoder increment i, no interest in the previous value. Auch hier werden Sie sich daran gewöhnen, auch wenn Sie es gerade nicht sind.
Knuth.
Vorzeitige Optimierung ist die Wurzel allen Übels. Da ist vorzeitige Pessimisierung.