Debería usar

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

o

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

ordenar un vector en orden descendente? ¿Hay algún beneficio o inconveniente con un enfoque u otro?

En realidad, el primero es una mala idea. Use el segundo o este:

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

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

De esa manera, su código no se romperá silenciosamente cuando alguien decida que numbersdebería retener longo en long longlugar de int.

Usa el primero:

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

Es explícito de lo que está pasando - menos posibilidades de mala interpretación rbeginque begin, incluso con un comentario. Es claro y legible, que es exactamente lo que quieres.

Además, el segundo puede ser menos eficiente que el primero dada la naturaleza de los iteradores inversos, aunque tendría que perfilarlo para estar seguro.

Con c ++ 14 puedes hacer esto:

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

¿Qué hay de esto?

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

En lugar de un functor como propuso Mehrdad, podría usar una función Lambda.

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

Según mi máquina, ordenar un long long vector de [1..3000000] usando el primer método toma alrededor de 4 segundos, mientras que usar el segundo toma aproximadamente el doble del tiempo. Eso dice algo, obviamente, pero tampoco entiendo por qué. Solo piensa que esto sería útil.

Lo mismo reportado aquí .

Como dijo Xeo, -O3usan casi el mismo tiempo para terminar.

El primer enfoque se refiere:

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

Puede usar el primer enfoque debido a que obtiene más eficiencia que el segundo.
La complejidad temporal del primer enfoque es menor que la segunda.

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

TL; DR

Usar cualquier. Son casi lo mismo.

Respuesta aburrida

Como de costumbre, hay pros y contras.

Uso std::reverse_iterator:

• Cuando está ordenando tipos personalizados y no desea implementar operator>()
• Cuando eres demasiado vago para escribir std::greater<int>()

Usar std::greatercuando:

• Cuando quieres tener un código más explícito
• Cuando desee evitar el uso de iteradores inversos oscuros

En cuanto al rendimiento, ambos métodos son igualmente eficientes. Probé el siguiente punto de referencia:

#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 esta línea de 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

Los tiempos son iguales. Valgrind informa el mismo número de errores de caché.

No creo que deba usar ninguno de los métodos en la pregunta, ya que ambos son confusos, y el segundo es frágil, como sugiere Mehrdad.

Yo recomendaría lo siguiente, ya que parece una función de biblioteca estándar y deja en claro su intención:

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

Puede usar el primero o probar el siguiente código, que es igualmente eficiente

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