//===----------------------------------------------------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // UNSUPPORTED: c++03, c++11, c++14 // template ::value_type>> // vector(InputIterator, InputIterator, Allocator = Allocator()) // -> vector::value_type, Allocator>; // // template>> // vector(from_range_t, R&&, Allocator = Allocator()) // -> vector, Allocator>; // C++23 #include #include #include #include // INT_MAX #include #include #include #include #include "deduction_guides_sfinae_checks.h" #include "test_macros.h" #include "test_iterators.h" #include "test_allocator.h" struct A {}; TEST_CONSTEXPR_CXX20 bool tests() { // Test the explicit deduction guides { const int arr[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }; std::vector vec(std::begin(arr), std::end(arr)); static_assert(std::is_same_v>, ""); assert(std::equal(vec.begin(), vec.end(), std::begin(arr), std::end(arr))); } { const long arr[] = {INT_MAX, 1L, 2L, 3L }; std::vector vec(std::begin(arr), std::end(arr), std::allocator()); static_assert(std::is_same_v, ""); assert(vec.size() == 4); assert(vec[0] == INT_MAX); assert(vec[1] == 1L); assert(vec[2] == 2L); } // Test the implicit deduction guides { // We don't expect this one to work. // std::vector vec(std::allocator()); // vector (allocator &) } { std::vector vec(1, A{}); // vector (size_type, T) static_assert(std::is_same_v, ""); static_assert(std::is_same_v>, ""); assert(vec.size() == 1); } { std::vector vec(1, A{}, test_allocator()); // vector (size_type, T, allocator) static_assert(std::is_same_v, ""); static_assert(std::is_same_v>, ""); assert(vec.size() == 1); } { std::vector vec{1U, 2U, 3U, 4U, 5U}; // vector(initializer-list) static_assert(std::is_same_v, ""); assert(vec.size() == 5); assert(vec[2] == 3U); } { std::vector vec({1.0, 2.0, 3.0, 4.0}, test_allocator()); // vector(initializer-list, allocator) static_assert(std::is_same_v, ""); static_assert(std::is_same_v>, ""); assert(vec.size() == 4); assert(vec[3] == 4.0); } { std::vector source; std::vector vec(source); // vector(vector &) static_assert(std::is_same_v, ""); static_assert(std::is_same_v>, ""); assert(vec.size() == 0); } #if TEST_STD_VER >= 23 { { std::vector c(std::from_range, std::array()); static_assert(std::is_same_v>); } { using Alloc = test_allocator; std::vector c(std::from_range, std::array(), Alloc()); static_assert(std::is_same_v>); } } #endif // A couple of vector tests, too! { std::vector vec(3, true); // vector(initializer-list) static_assert(std::is_same_v, ""); static_assert(std::is_same_v>, ""); assert(vec.size() == 3); assert(vec[0] && vec[1] && vec[2]); } { std::vector source; std::vector vec(source); // vector(vector &) static_assert(std::is_same_v, ""); static_assert(std::is_same_v>, ""); assert(vec.size() == 0); } { typedef test_allocator Alloc; typedef test_allocator ConvertibleToAlloc; { std::vector source; std::vector vec(source, Alloc(2)); static_assert(std::is_same_v); } { std::vector source; std::vector vec(source, ConvertibleToAlloc(2)); static_assert(std::is_same_v); } { std::vector source; std::vector vec(std::move(source), Alloc(2)); static_assert(std::is_same_v); } { std::vector source; std::vector vec(std::move(source), ConvertibleToAlloc(2)); static_assert(std::is_same_v); } } SequenceContainerDeductionGuidesSfinaeAway>(); return true; } int main(int, char**) { tests(); #if TEST_STD_VER > 17 static_assert(tests()); #endif return 0; }