112 lines · cpp
1//===----------------------------------------------------------------------===//2//3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.4// See https://llvm.org/LICENSE.txt for license information.5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception6//7//===----------------------------------------------------------------------===//8 9// UNSUPPORTED: c++03, c++11, c++14, c++17, c++2010 11// <utility>12 13// template <class T1, class T2> struct pair14 15// template <pair-like P> constexpr pair& operator=(P&&); // since C++2316 17#include <array>18#include <cassert>19#include <concepts>20#include <ranges>21#include <string>22#include <tuple>23#include <type_traits>24#include <utility>25 26constexpr bool test() {27 // Make sure assignment works from array and tuple28 {29 // Check from std::array30 {31 std::array<int, 2> a = {1, 2};32 std::pair<int, int> p;33 std::same_as<std::pair<int, int>&> decltype(auto) result = (p = a);34 assert(&result == &p);35 assert(p.first == 1);36 assert(p.second == 2);37 static_assert(!std::is_assignable_v<std::pair<int, int>&, std::array<int, 1>>); // too small38 static_assert( std::is_assignable_v<std::pair<int, int>&, std::array<int, 2>>); // works (test the test)39 static_assert(!std::is_assignable_v<std::pair<int, int>&, std::array<int, 3>>); // too large40 }41 42 // Check from std::tuple43 {44 std::tuple<int, int> a = {1, 2};45 std::pair<int, int> p;46 std::same_as<std::pair<int, int>&> decltype(auto) result = (p = a);47 assert(&result == &p);48 assert(p.first == 1);49 assert(p.second == 2);50 static_assert(!std::is_assignable_v<std::pair<int, int>&, std::tuple<int>>); // too small51 static_assert( std::is_assignable_v<std::pair<int, int>&, std::tuple<int, int>>); // works (test the test)52 static_assert(!std::is_assignable_v<std::pair<int, int>&, std::tuple<int, int, int>>); // too large53 }54 55 // Make sure it works for ranges::subrange. This actually deserves an explanation: even though56 // the assignment operator explicitly excludes ranges::subrange specializations, such assignments57 // end up working because of ranges::subrange's implicit conversion to pair-like types.58 // This test ensures that the interoperability works as intended.59 {60 struct Assignable {61 int* ptr = nullptr;62 Assignable() = default;63 constexpr Assignable(int* p) : ptr(p) { } // enable `subrange::operator pair-like`64 constexpr Assignable& operator=(Assignable const&) = default;65 };66 int data[] = {1, 2, 3, 4, 5};67 std::ranges::subrange<int*> a(data);68 std::pair<Assignable, Assignable> p;69 std::same_as<std::pair<Assignable, Assignable>&> decltype(auto) result = (p = a);70 assert(&result == &p);71 assert(p.first.ptr == data);72 assert(p.second.ptr == data + 5);73 }74 }75 76 // Make sure we allow element conversion from a pair-like77 {78 std::tuple<int, char const*> a = {34, "hello world"};79 std::pair<long, std::string> p;80 std::same_as<std::pair<long, std::string>&> decltype(auto) result = (p = a);81 assert(&result == &p);82 assert(p.first == 34);83 assert(p.second == std::string("hello world"));84 static_assert(!std::is_assignable_v<std::pair<long, std::string>&, std::tuple<char*, std::string>>); // first not convertible85 static_assert(!std::is_assignable_v<std::pair<long, std::string>&, std::tuple<long, void*>>); // second not convertible86 static_assert( std::is_assignable_v<std::pair<long, std::string>&, std::tuple<long, std::string>>); // works (test the test)87 }88 89 // Make sure we forward the pair-like elements90 {91 struct NoCopy {92 NoCopy() = default;93 NoCopy(NoCopy const&) = delete;94 NoCopy(NoCopy&&) = default;95 NoCopy& operator=(NoCopy const&) = delete;96 NoCopy& operator=(NoCopy&&) = default;97 };98 std::tuple<NoCopy, NoCopy> a;99 std::pair<NoCopy, NoCopy> p;100 p = std::move(a);101 }102 103 return true;104}105 106int main(int, char**) {107 test();108 static_assert(test());109 110 return 0;111}112