TL; DR
Utilisez n'importe lequel. Ce sont presque les mêmes.
Réponse ennuyeuse
Comme d'habitude, il y a des avantages et des inconvénients.
Utilisation std::reverse_iterator
:
- Lorsque vous triez des types personnalisés et que vous ne souhaitez pas implémenter
operator>()
- Quand tu es trop paresseux pour taper
std::greater<int>()
À utiliser std::greater
lorsque:
- Lorsque vous voulez avoir un code plus explicite
- Lorsque vous voulez éviter d'utiliser des itérateurs inverses obscurs
Quant aux performances, les deux méthodes sont tout aussi efficaces. J'ai essayé le benchmark suivant:
#include <algorithm>
#include <chrono>
#include <iostream>
#include <fstream>
#include <vector>
using namespace std::chrono;
/* 64 Megabytes. */
#define VECTOR_SIZE (((1 << 20) * 64) / sizeof(int))
/* Number of elements to sort. */
#define SORT_SIZE 100000
int main(int argc, char **argv) {
std::vector<int> vec;
vec.resize(VECTOR_SIZE);
/* We generate more data here, so the first SORT_SIZE elements are evicted
from the cache. */
std::ifstream urandom("/dev/urandom", std::ios::in | std::ifstream::binary);
urandom.read((char*)vec.data(), vec.size() * sizeof(int));
urandom.close();
auto start = steady_clock::now();
#if USE_REVERSE_ITER
auto it_rbegin = vec.rend() - SORT_SIZE;
std::sort(it_rbegin, vec.rend());
#else
auto it_end = vec.begin() + SORT_SIZE;
std::sort(vec.begin(), it_end, std::greater<int>());
#endif
auto stop = steady_clock::now();
std::cout << "Sorting time: "
<< duration_cast<microseconds>(stop - start).count()
<< "us" << std::endl;
return 0;
}
Avec cette ligne de commande:
g++ -g -DUSE_REVERSE_ITER=0 -std=c++11 -O3 main.cpp \
&& valgrind --cachegrind-out-file=cachegrind.out --tool=cachegrind ./a.out \
&& cg_annotate cachegrind.out
g++ -g -DUSE_REVERSE_ITER=1 -std=c++11 -O3 main.cpp \
&& valgrind --cachegrind-out-file=cachegrind.out --tool=cachegrind ./a.out \
&& cg_annotate cachegrind.out
std::greater
demo
std::reverse_iterator
demo
Les horaires sont les mêmes. Valgrind signale le même nombre d'échecs de cache.