std::list::sort(3)

💅 std::list::sort ✨

okay so this is std::list::sort from the C++ Standard Library manual (yes, the whole <list> bestie universe) and it's literally the glow-up your list has been waiting for 🎀

✨ NAME ✨

std::list::sort — it's std::list::sort, she's an icon, she sorts your list, that's the vibe 💅

🌸 SYNOPSIS 🌸

void sort();               (1)
template< class Compare >  (2)
void sort( Compare comp );

So here's the tea: sort sorts the elements and preserves the order of equivalent elements (stable queen behavior 👑). No references or iterators become invalidated — not a single one, no cap.

1. Elements are compared using operator<.
2. Elements are compared using comp.

🫶 real talk: if an exception is thrown, the order of elements in *this is unspecified. so like… the vibes are unguaranteed. be careful.

🦋 PARAMETERS 🦋

• comp — a comparison function object (i.e. an object that satisfies the requirements of Compare) which returns true if the first argument is less than (i.e. is ordered before) the second.

The signature of the comparison function should be equivalent to the following:

bool cmp(const Type1& a, const Type2& b);

While the signature does not need to have const&, the function must not modify the objects passed to it and must be able to accept all values of type (possibly const) Type1 and Type2 regardless of value category (thus, Type1& is not allowed, nor is Type1 unless for Type1 a move is equivalent to a copy (since C++11)). The types Type1 and Type2 must be such that an object of type list<T,Allocator>::const_iterator can be dereferenced and then implicitly converted to both of them. iykyk 💜

🌈 TYPE REQUIREMENTS 🌈

• Compare must meet the requirements of Compare.

⭐ RETURN VALUE ⭐

(none) — she gives you nothing back except a sorted list. iconic, honestly. 💀

🔥 COMPLEXITY 🔥

Given N as size():

1. Approximately N·log(N) comparisons using operator<.
2. Approximately N·log(N) applications of the comparison function comp.

so it's giving efficient, it's giving logarithmic, it's giving slay ✨

🧚 NOTES 🧚

okay this part matters bestie 🙈 std::sort requires random access iterators and so cannot be used with list. This function also differs from std::sort in that it does not require the element type of the list to be swappable, preserves the values of all iterators, and performs a stable sort. three whole flexes. periodt. 💅

🍓 EXAMPLE 🍓

// Run this code

#include <functional>
#include <iostream>
#include <list>

std::ostream& operator<<(std::ostream& ostr, const std::list<int>& list)
{
    for (const int i : list)
        ostr << ' ' << i;
    return ostr;
}

int main()
{
    std::list<int> list{8, 7, 5, 9, 0, 1, 3, 2, 6, 4};
    std::cout << "initially: " << list << '\n';

    list.sort();
    std::cout << "ascending: " << list << '\n';

    list.sort(std::greater<int>());
    std::cout << "descending:" << list << '\n';
}

Output:

initially:  8 7 5 9 0 1 3 2 6 4
ascending:  0 1 2 3 4 5 6 7 8 9
descending: 9 8 7 6 5 4 3 2 1 0

look at her go 😭 she ate and left no crumbs 🫶

👑 DEFECT REPORTS 👑

The following behavior-changing defect reports were applied retroactively to previously published C++ standards — like a patch note but for the past 🕰️

• LWG 1207 — Applied to: C++98.
  • Behavior as published: it was unclear whether iterators and/or references will be invalidated.
  • Correct behavior: keep valid.

ngl that's the good ending 💖

🌸 SEE ALSO 🌸

• reverse — reverses the order of the elements (public member function)

---

okay that's the whole page bestie, you're officially educated 💅✨ she's from http://cppreference.com, dated 2024.06.10, and the manual page itself is std::list::sort(3) — go forth and sort your lists, you've got this 🎀🦋💜