generate_n(OutputIterator first, Size n, Generator gen);
template <class ForwardIterator, class T>
- ForwardIterator
+ constexpr ForwardIterator // constexpr in C++20
remove(ForwardIterator first, ForwardIterator last, const T& value);
template <class ForwardIterator, class Predicate>
- ForwardIterator
+ constexpr ForwardIterator // constexpr in C++20
remove_if(ForwardIterator first, ForwardIterator last, Predicate pred);
template <class InputIterator, class OutputIterator, class T>
- OutputIterator
+ constexpr OutputIterator // constexpr in C++20
remove_copy(InputIterator first, InputIterator last, OutputIterator result, const T& value);
template <class InputIterator, class OutputIterator, class Predicate>
- OutputIterator
+ constexpr OutputIterator // constexpr in C++20
remove_copy_if(InputIterator first, InputIterator last, OutputIterator result, Predicate pred);
template <class ForwardIterator>
reverse(BidirectionalIterator first, BidirectionalIterator last);
template <class BidirectionalIterator, class OutputIterator>
- OutputIterator
+ constexpr OutputIterator // constexpr in C++20
reverse_copy(BidirectionalIterator first, BidirectionalIterator last, OutputIterator result);
template <class ForwardIterator>
// remove
template <class _ForwardIterator, class _Tp>
-_ForwardIterator
+_LIBCPP_CONSTEXPR_AFTER_CXX17 _ForwardIterator
remove(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value_)
{
__first = _VSTD::find(__first, __last, __value_);
// remove_if
template <class _ForwardIterator, class _Predicate>
-_ForwardIterator
+_LIBCPP_CONSTEXPR_AFTER_CXX17 _ForwardIterator
remove_if(_ForwardIterator __first, _ForwardIterator __last, _Predicate __pred)
{
__first = _VSTD::find_if<_ForwardIterator, typename add_lvalue_reference<_Predicate>::type>
// remove_copy
template <class _InputIterator, class _OutputIterator, class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
_OutputIterator
remove_copy(_InputIterator __first, _InputIterator __last, _OutputIterator __result, const _Tp& __value_)
{
// remove_copy_if
template <class _InputIterator, class _OutputIterator, class _Predicate>
-inline _LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
_OutputIterator
remove_copy_if(_InputIterator __first, _InputIterator __last, _OutputIterator __result, _Predicate __pred)
{
// reverse_copy
template <class _BidirectionalIterator, class _OutputIterator>
-inline _LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
_OutputIterator
reverse_copy(_BidirectionalIterator __first, _BidirectionalIterator __last, _OutputIterator __result)
{
// template<ForwardIterator Iter, class T>
// requires OutputIterator<Iter, RvalueOf<Iter::reference>::type>
// && HasEqualTo<Iter::value_type, T>
-// Iter
+// constexpr Iter // constexpr after C++17
// remove(Iter first, Iter last, const T& value);
#include <algorithm>
#include "test_macros.h"
#include "test_iterators.h"
+#if TEST_STD_VER > 17
+TEST_CONSTEXPR bool test_constexpr() {
+ int ia[] = {1, 3, 5, 2, 5, 6};
+
+ auto it = std::remove(std::begin(ia), std::end(ia), 5);
+
+ return (std::begin(ia) + std::size(ia) - 2) == it // we removed two elements
+ && std::none_of(std::begin(ia), it, [](int a) {return a == 5; })
+ ;
+ }
+#endif
+
template <class Iter>
void
test()
test1<random_access_iterator<std::unique_ptr<int>*> >();
test1<std::unique_ptr<int>*>();
#endif // TEST_STD_VER >= 11
+
+#if TEST_STD_VER > 17
+ static_assert(test_constexpr());
+#endif
}
// template<InputIterator InIter, OutputIterator<auto, InIter::reference> OutIter, class T>
// requires HasEqualTo<InIter::value_type, T>
-// OutIter
+// constexpr OutIter // constexpr after C++17
// remove_copy(InIter first, InIter last, OutIter result, const T& value);
#include <algorithm>
#include <cassert>
+#include "test_macros.h"
#include "test_iterators.h"
+#if TEST_STD_VER > 17
+TEST_CONSTEXPR bool test_constexpr() {
+ int ia[] = {1, 3, 5, 2, 5, 6};
+ int ib[std::size(ia)] = {0};
+
+ auto it = std::remove_copy(std::begin(ia), std::end(ia), std::begin(ib), 5);
+
+ return std::distance(std::begin(ib), it) == (std::size(ia) - 2) // we removed two elements
+ && std::none_of(std::begin(ib), it, [](int a) {return a == 5;})
+ && std::all_of (it, std::end(ib), [](int a) {return a == 0;})
+ ;
+ }
+#endif
+
template <class InIter, class OutIter>
void
test()
test<const int*, bidirectional_iterator<int*> >();
test<const int*, random_access_iterator<int*> >();
test<const int*, int*>();
+
+#if TEST_STD_VER > 17
+ static_assert(test_constexpr());
+#endif
}
// template<InputIterator InIter, OutputIterator<auto, InIter::reference> OutIter,
// Predicate<auto, InIter::value_type> Pred>
// requires CopyConstructible<Pred>
-// OutIter
+// constexpr OutIter // constexpr after C++17
// remove_copy_if(InIter first, InIter last, OutIter result, Pred pred);
#include <algorithm>
#include <functional>
#include <cassert>
+#include "test_macros.h"
#include "test_iterators.h"
-bool equalToTwo(int v) { return v == 2; }
+TEST_CONSTEXPR bool equalToTwo(int v) { return v == 2; }
+
+#if TEST_STD_VER > 17
+TEST_CONSTEXPR bool test_constexpr() {
+ int ia[] = {1, 3, 5, 2, 5, 6};
+ int ib[std::size(ia)] = {0};
+
+ auto it = std::remove_copy_if(std::begin(ia), std::end(ia), std::begin(ib), equalToTwo);
+
+ return std::distance(std::begin(ib), it) == (std::size(ia) - 1) // we removed one element
+ && std::none_of(std::begin(ib), it, equalToTwo)
+ && std::all_of (it, std::end(ib), [](int a) {return a == 0;})
+ ;
+ }
+#endif
template <class InIter, class OutIter>
void
test<const int*, bidirectional_iterator<int*> >();
test<const int*, random_access_iterator<int*> >();
test<const int*, int*>();
+
+#if TEST_STD_VER > 17
+ static_assert(test_constexpr());
+#endif
}
// template<ForwardIterator Iter, Predicate<auto, Iter::value_type> Pred>
// requires OutputIterator<Iter, RvalueOf<Iter::reference>::type>
// && CopyConstructible<Pred>
-// Iter
+// constexpr Iter // constexpr after C++17
// remove_if(Iter first, Iter last, Pred pred);
#include <algorithm>
#include "test_iterators.h"
#include "counting_predicates.hpp"
-bool equal2 ( int i ) { return i == 2; }
+TEST_CONSTEXPR bool equal2 ( int i ) { return i == 2; }
+
+#if TEST_STD_VER > 17
+TEST_CONSTEXPR bool test_constexpr() {
+ int ia[] = {1, 3, 5, 2, 5, 6};
+
+ auto it = std::remove_if(std::begin(ia), std::end(ia), equal2);
+
+ return (std::begin(ia) + std::size(ia) - 1) == it // we removed one element
+ && std::none_of(std::begin(ia), it, equal2)
+ ;
+ }
+#endif
template <class Iter>
void
test1<random_access_iterator<std::unique_ptr<int>*> >();
test1<std::unique_ptr<int>*>();
#endif // TEST_STD_VER >= 11
+
+#if TEST_STD_VER > 17
+ static_assert(test_constexpr());
+#endif
}
// <algorithm>
// template<BidirectionalIterator InIter, OutputIterator<auto, InIter::reference> OutIter>
-// OutIter
+// constexpr OutIter // constexpr after C++17
// reverse_copy(InIter first, InIter last, OutIter result);
#include <algorithm>
#include <cassert>
+#include "test_macros.h"
#include "test_iterators.h"
+#if TEST_STD_VER > 17
+TEST_CONSTEXPR bool test_constexpr() {
+ int ia[] = {1, 3, 5, 2, 5, 6};
+ int ib[std::size(ia)] = {0};
+
+ auto it = std::reverse_copy(std::begin(ia), std::end(ia), std::begin(ib));
+
+ return std::distance(std::begin(ib), it) == std::size(ia)
+ && std::equal (std::begin(ia), std::end(ia), std::rbegin(ib))
+ ;
+ }
+#endif
+
template <class InIter, class OutIter>
void
test()
test<const int*, bidirectional_iterator<int*> >();
test<const int*, random_access_iterator<int*> >();
test<const int*, int*>();
+
+#if TEST_STD_VER > 17
+ static_assert(test_constexpr());
+#endif
}
// <algorithm>
// template<ForwardIterator InIter, OutputIterator<auto, InIter::reference> OutIter>
-// OutIter
+// constexpr OutIter // constexpr after C++17
// rotate_copy(InIter first, InIter middle, InIter last, OutIter result);
#include <algorithm>
#include <cassert>
+#include "test_macros.h"
#include "test_iterators.h"
+// #if TEST_STD_VER > 17
+// TEST_CONSTEXPR bool test_constexpr() {
+// int ia[] = {1, 3, 5, 2, 5, 6};
+// int ib[std::size(ia)] = {0};
+//
+// const size_t N = 2;
+// const auto middle = std::begin(ia) + N;
+// auto it = std::rotate_copy(std::begin(ia), middle, std::end(ia), std::begin(ib));
+//
+// return std::distance(std::begin(ib), it) == std::size(ia)
+// && std::equal (std::begin(ia), middle, std::begin(ib) + std::size(ia) - N)
+// && std::equal (middle, std::end(ia), std::begin(ib))
+// ;
+// }
+// #endif
+
template <class InIter, class OutIter>
void
test()
test<const int*, bidirectional_iterator<int*> >();
test<const int*, random_access_iterator<int*> >();
test<const int*, int*>();
+
+// #if TEST_STD_VER > 17
+// static_assert(test_constexpr());
+// #endif
}