This is an implementation of the quick sort algorithm, written from memory as an excersice.

quick_sort.cpp

#include <utility> // For std::swap

template <typename T>
void quick_sort(T array[], size_t size)
{
	constexpr auto npos = (size_t{ 0 } - 1);

	// Empty or doesn't need sorting
	if (size <= 1)
		return;

	// Select the last element as pivot
	auto pivotIndex = size - 1;
	auto& pivotValue = array[pivotIndex];

	auto leftIterator = size_t{ 0 };
	auto rightIterator = pivotIndex - 1;

	while (rightIterator != npos && rightIterator >= leftIterator)
	{
		// increase the left iterator until we find a value that is higher than the pivot value or it crosses bounds
		while (leftIterator < pivotIndex && array[leftIterator] <= pivotValue)
			leftIterator++;

		// decrease the right iterator until we find a value that is lower than the pivot value or it crosses bounds
		while (rightIterator != npos && rightIterator >= leftIterator && array[rightIterator] > pivotValue)
			rightIterator--;

		if (rightIterator != npos && rightIterator >= leftIterator)
			std::swap(array[leftIterator], array[rightIterator]);
	}

	// The pivot value should be on the left iterator's position
	std::swap(array[leftIterator], array[pivotIndex]);

	// Recursively sort each side of the pivot point. Everything on the left side is lower and everything on the right side is higher than it
	quick_sort(array, leftIterator);
	quick_sort(array + leftIterator + 1, size - leftIterator - 1);
}

// Allow calling quick_sort on a static array
template<typename T, size_t N>
void quick_sort(T(&array)[N])
{
	quick_sort(array, N);
}