Dovrei usare

std::sort(numbers.begin(), numbers.end(), std::greater<int>());

o

std::sort(numbers.rbegin(), numbers.rend());   // note: reverse iterators

ordinare un vettore in ordine decrescente? Ci sono vantaggi o svantaggi con un approccio o l'altro?

In realtà, la prima è una cattiva idea. Usa il secondo o questo:

struct greater
{
    template<class T>
    bool operator()(T const &a, T const &b) const { return a > b; }
};

std::sort(numbers.begin(), numbers.end(), greater());

In questo modo il tuo codice non si romperà silenziosamente quando qualcuno decide di numbersconservare longo long longinvece di int.

Usa il primo:

std::sort(numbers.begin(), numbers.end(), std::greater<int>());

È esplicito quello che sta succedendo - meno possibilità di interpretare male rbegincome begin, anche con un commento. È chiaro e leggibile che è esattamente quello che vuoi.

Inoltre, il secondo potrebbe essere meno efficiente del primo, data la natura degli iteratori inversi, anche se si dovrebbe profilarlo per sicurezza.

Con c ++ 14 puoi fare questo:

std::sort(numbers.begin(), numbers.end(), std::greater<>());

Che dire di questo?

std::sort(numbers.begin(), numbers.end());
std::reverse(numbers.begin(), numbers.end());

Invece di un funzione come proposto da Mehrdad, potresti usare una funzione Lambda.

sort(numbers.begin(), numbers.end(), [](const int a, const int b) {return a > b; });

Secondo la mia macchina, l'ordinamento di un long longvettore di [1..3000000] utilizzando il primo metodo richiede circa 4 secondi, mentre l'utilizzo del secondo richiede circa il doppio del tempo. Questo dice qualcosa, ovviamente, ma non capisco neanche perché. Basti pensare che questo sarebbe utile.

Stessa cosa riportata qui .

Come detto da Xeo, -O3usano quasi lo stesso tempo per finire.

Il primo approccio si riferisce:

    std::sort(numbers.begin(), numbers.end(), std::greater<>());

È possibile utilizzare il primo approccio per ottenere più efficienza del secondo.
La complessità temporale del primo approccio è inferiore alla seconda.

bool comp(int i, int j) { return i > j; }
sort(numbers.begin(), numbers.end(), comp);

TL; DR

Usa qualsiasi Sono quasi uguali.

Risposta noiosa

Come al solito, ci sono pro e contro.

Utilizzare std::reverse_iterator:

• Quando si ordinano tipi personalizzati e non si desidera implementare operator>()
• Quando sei troppo pigro per scrivere std::greater<int>()

Utilizzare std::greaterquando:

• Quando vuoi avere un codice più esplicito
• Quando si desidera evitare l'uso di iteratori inversi oscuri

Per quanto riguarda le prestazioni, entrambi i metodi sono ugualmente efficienti. Ho provato il seguente benchmark:

#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;
}

Con questa riga di comando:

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

I tempi sono gli stessi. Valgrind riporta lo stesso numero di errori nella cache.

Non penso che dovresti usare nessuno dei due metodi nella domanda poiché sono entrambi confusi, e il secondo è fragile come suggerisce Mehrdad.

Suggerirei quanto segue, in quanto sembra una funzione di libreria standard e chiarisce la sua intenzione:

#include <iterator>

template <class RandomIt>
void reverse_sort(RandomIt first, RandomIt last)
{
    std::sort(first, last, 
        std::greater<typename std::iterator_traits<RandomIt>::value_type>());
}

Puoi usare il primo o provare il codice qui sotto che è ugualmente efficiente

sort(&a[0], &a[n], greater<int>());