Compile with C++17 (#66)

Author: Morwenn

CMakeLists.txt

@@ -37,7 +37,7 @@ target_include_directories(cpp-sort INTERFACE
     $<INSTALL_INTERFACE:include>
 )
 
-target_compile_features(cpp-sort INTERFACE cxx_std_14)
+target_compile_features(cpp-sort INTERFACE cxx_std_17)
 
 # MSVC won't work without a stricter standard compliance
 if (MSVC)

README.md

@@ -11,7 +11,7 @@
 > since there are some applications in which they turn out to be best.*
 > — Donald Knuth, The Art Of Computer Programming, Volume 3
 
-**cpp-sort** is a generic C++14 header-only sorting library. It revolves
+**cpp-sort** is a generic C++17 header-only sorting library. It revolves
 around one main generic sorting interface and provides several small tools
 to pick and/or design sorting algorithms. Using its basic sorting features
 should be trivial enough:
@@ -121,7 +121,7 @@ page][benchmarks].
 ![Windows builds status](https://github.com/Morwenn/cpp-sort/workflows/MSVC%20Builds/badge.svg?branch=develop)
 ![MacOS builds status](https://github.com/Morwenn/cpp-sort/workflows/MacOS%20Builds/badge.svg?branch=develop)
 
-**cpp-sort** requires C++14 support, and should work with the following compilers:
+**cpp-sort** requires C++17 support, and should work with the following compilers:
 * g++-9 or more recent.
 * clang++-11 or more recent (with both libstdc++ and libc++).
 * The versions of MinGW-w64 and AppleClang equivalent to the compilers mentioned above.

docs/Changelog.md

@@ -1,8 +1,8 @@
-This page describes the features that change in **cpp-sort** depending on the C++ version with which it is compiled (C++14 or later) as well as the support for miscellaneous compiler extensions; for a full changelog between actual releases, you can check the dedicated [releases page][cpp-sort-releases].
+This page describes the features that change in **cpp-sort** depending on the C++ version with which it is compiled (C++17 or later) as well as the support for miscellaneous compiler extensions; for a full changelog between actual releases, you can check the dedicated [releases page][cpp-sort-releases].
 
 ## C++14 features
 
-While **cpp-sort** theoretically requires a fully C++14-compliant compiler, a few standard features are either not available or deactivated in popular compilers and the library tries to take those into account if possible.
+While **cpp-sort** theoretically requires a fully C++17-compliant compiler, a few standard features are either not available or deactivated in some popular compilers and the library tries to take those into account when possible.
 
 **Performance improvements:**
 * Sized deallocation: this C++14 feature is not always available (Clang requires `-fsized-deallocation` for example) and standard allocation functions typically don't take advantage of it. However, if `__cpp_sized_deallocation` is defined and the global deallocations functions are replaced with overloads that take advantage of sized deallocation, then several sorters will explicitly try to take advantage of it.

docs/Measures-of-presortedness.md

@@ -52,10 +52,10 @@ Note however that most of these algorithms can be expensive. Using them before a
 Measures of presortedness can be used with the *sorter adapters* from the library. Even though most of the adapters are meaningless with measures of presortedness, some of them can still be used to mitigate space and time:
 
 ```cpp
-// C++14
+// With explicit template parameter
 auto inv = cppsort::indirect_adapter<decltype(cppsort::probe::inv)>{};
 
-// C++17
+// With CTAD
 auto inv = cppsort::indirect_adapter(cppsort::probe::inv);
 ```
 

docs/Sorter-adapters.md

@@ -9,11 +9,11 @@ In this documentation, we call *adapted sorters* the sorters passed to the adapt
 In C++17, *sorter adapters* can be used in a function-like fashion thanks to `explicit` constructors (taking one or several sorters) by taking advantage of implicit [deduction guides][ctad]. The following example illustrates how it simplifies their use:
 
 ```cpp
-// C++14
+// With explicit template parameter
 using sorter = indirect_adapter<quick_sorter>;
 constexpr auto sort = sorter{};
 
-// C++17
+// With CTAD
 constexpr auto sort = indirect_adapter(quick_sort);
 ```
 

docs/Writing-a-bubble_sorter.md

@@ -290,7 +290,7 @@ Generic agorithms are good, more generic algorithms are sometimes better. The cu
 
 C++20 ranges introduces the notion of ["proxy iterators"][proxy-iterators], which are basically iterators that can't yield a proper reference to the object they point to, but instead yield a proxy object acting as a reference. In order to handle such iterators, C++20 introduces the *customization point objects* [`std::ranges::iter_move`][std-iter-move] and [`std::ranges::iter_swap`][std-iter-swap] which should be used instead of `std::move(*it)` and `std::iter_swap(it1, it2)` in generic algorithms that aim to support proxy iterators.
 
-**cpp-sort** being a C++14 library, it can't rely on these CPOs and provides the utility functions [`utility::iter_move` and `utility::iter_swap`][utility-iter-move] to replace them. They are a bit cruder than their standard equivalents you have to import them into the current namespace and perform an unqualified call, *à la* `std::swap`.
+**cpp-sort** being a C++17 library, it can't rely on these CPOs and provides the utility functions [`utility::iter_move` and `utility::iter_swap`][utility-iter-move] to replace them. They are a bit cruder than their standard equivalents you have to import them into the current namespace and perform an unqualified call, *à la* `std::swap`.
 
 ```cpp
 template<typename ForwardIterator, typename Compare>