Чи варто використовувати

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

або

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

сортувати вектор у порядку зменшення? Чи є якісь переваги чи недоліки при одному чи іншому підході?

Власне, перша - погана ідея. Використовуйте або другий , або цей:

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

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

Таким чином ваш код не мовчить зламатися, коли хтось вирішить, що він numbersповинен утримувати longабо long longзамість цього int.

Скористайтеся першим:

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

Це явно що відбувається - менше шансів спотворення , rbeginяк begin, навіть з коментарем. Це чітко і читабельно, що саме ви хочете.

Крім того, другий може бути менш ефективним, ніж перший, враховуючи характер зворотних ітераторів, хоча вам доведеться переглядати це, щоб бути впевненим.

За допомогою c ++ 14 ви можете це зробити:

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

Як що до цього?

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

Замість функтора, як запропонував Мехрдад, ви можете використовувати функцію лямбда.

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

За моєю машиною, сортування long longвектора [1..3000000] за допомогою першого методу займає приблизно 4 секунди, тоді як використання другого займає приблизно вдвічі більше часу. Це, очевидно, щось говорить, але я не розумію, чому також. Просто подумайте, що це було б корисно.

Тут повідомляється те саме .

За словами Xeo, -O3вони використовують приблизно той самий час, щоб закінчити.

Перший підхід стосується:

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

Ви можете використовувати перший підхід через отримання більшої ефективності, ніж другий.
Час складності першого підходу менший, ніж другий.

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

TL; DR

Використовуйте будь-який. Вони майже однакові.

Нудна відповідь

Як завжди, є плюси і мінуси.

Використання std::reverse_iterator:

• Коли ви сортуєте власні типи та не хочете їх реалізувати operator>()
• Коли ти лінивий набрати std::greater<int>()

Використовувати, std::greaterколи:

• Коли ви хочете мати більш явний код
• Коли ви хочете уникати використання незрозумілих ітераторів зворотного ходу

Щодо продуктивності, обидва способи однаково ефективні. Я спробував наступний орієнтир:

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

За допомогою цього командного рядка:

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

Терміни однакові. Valgrind повідомляє про стільки ж пропусків кешу.

Я не думаю, що ви не повинні використовувати жоден із методів у питанні, оскільки вони обидва заплутані, а другий - тендітний, як пропонує Мехрдад.

Я б виступав за наступне, оскільки це виглядає як стандартна функція бібліотеки і робить її намір зрозумілим:

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

Ви можете скористатися першим або спробувати код, який нижче є однаково ефективним

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