# std::forward_list<T,Allocator>::sort

> C++ Atlas: `cppatlas.com/w/cpp/container/forward_list/sort` | Source: https://en.cppreference.com/w/cpp/container/forward_list/sort | Domain: Containers | Standards: C++11

Sorts the elements and preserves the order of equivalent elements. No references or iterators become invalidated.

## Official Specification Summary (cppreference)

```cpp
void sort(); // (1) (since C++11)

template< class Compare >
void sort( Compare comp ); // (2) (since C++11)
```

Sorts the elements and preserves the order of equivalent elements. No references or iterators become invalidated.

1) Elements are compared using `operator<`.

2) Elements are compared using `comp`.

If an exception is thrown, the order of elements in `*this` is unspecified.

### Parameters

- `comp` - 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 `forward_list<T,Allocator>::const_iterator` can be dereferenced and then implicitly converted to both of them.

**Type requirements**

- `Compare` must meet the requirements of *Compare*.

### Return value

(none)

### Complexity

Given N as `std::distance(begin(), end())`:

1) Approximately N·log(N) comparisons using `operator<`.

2) Approximately N·log(N) applications of the comparison function `comp`.

### Notes

`std::sort` requires random access iterators and so cannot be used with `forward_list`. This function also differs from `std::sort` in that it does not require the element type of the `forward_list` to be swappable, preserves the values of all iterators, and performs a stable sort.

### Example

```cpp
#include <functional>
#include <iostream>
#include <forward_list>

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

int main()
{
    std::forward_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:

```text
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
```

### See also

- [`reverse`](https://en.cppreference.com/w/cpp/container/forward_list/reverse): reverses the order of the elements (public member function)

---
Attribution: content from https://en.cppreference.com/w/cpp/container/forward_list/sort (cppreference.com), licensed under CC-BY-SA 3.0 and GFDL. Modified: converted to markdown, study notes added. Offline snapshot of 9 February 2025.