Voici une référence pour le cas où les opérateurs d'incrémentation sont dans différentes unités de traduction. Compilateur avec g ++ 4.5.
Ignorez les problèmes de style pour l'instant
// 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;
}
Incrément O (n)
Tester
// 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;
}
Résultats
Résultats (les temps sont en secondes) avec g ++ 4.5 sur une machine virtuelle:
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
Incrément O (1)
Tester
Prenons maintenant le fichier suivant:
// 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;
}
Cela ne fait rien dans l'incrémentation. Cela simule le cas où l'incrémentation a une complexité constante.
Résultats
Les résultats varient désormais considérablement:
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
Conclusion
Côté performance
Si vous n'avez pas besoin de la valeur précédente, prenez l'habitude d'utiliser le pré-incrément. Soyez cohérent même avec les types intégrés, vous vous y habituerez et ne courrez pas le risque de subir des pertes de performances inutiles si vous remplacez un type intégré par un type personnalisé.
Sémantique
i++ dit increment i, I am interested in the previous value, though .++idit increment i, I am interested in the current valueou increment i, no interest in the previous value. Encore une fois, vous vous y habituerez, même si vous n'êtes pas en ce moment.
Knuth.
L'optimisation prématurée est la racine de tout Mal. Tout comme la pessimisation prématurée.