1 // Copyright (C) 2019-2021 Free Software Foundation, Inc. 2 // 3 // This file is part of the GNU ISO C++ Library. This library is free 4 // software; you can redistribute it and/or modify it under the 5 // terms of the GNU General Public License as published by the 6 // Free Software Foundation; either version 3, or (at your option) 7 // any later version. 8 9 // This library is distributed in the hope that it will be useful, 10 // but WITHOUT ANY WARRANTY; without even the implied warranty of 11 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 // GNU General Public License for more details. 13 14 // You should have received a copy of the GNU General Public License along 15 // with this library; see the file COPYING3. If not see 16 // <http://www.gnu.org/licenses/>. 17 18 // { dg-options "-std=gnu++2a" } 19 // { dg-do compile { target c++2a } } 20 21 #include <concepts> 22 23 static_assert( std::copyable<int> ); 24 static_assert( std::copyable<int*> ); 25 static_assert( ! std::copyable<int&> ); 26 static_assert( ! std::copyable<void> ); 27 static_assert( ! std::copyable<void()> ); 28 static_assert( ! std::copyable<void() noexcept> ); 29 static_assert( ! std::copyable<void() const> ); 30 31 struct Trivial { }; 32 static_assert( std::copyable<Trivial> ); 33 34 struct NotTrivial 35 { NotTrivialNotTrivial36 NotTrivial(int) { } NotTrivialNotTrivial37 NotTrivial(const NotTrivial&) { } operator =NotTrivial38 NotTrivial& operator=(const NotTrivial&) { return *this; } ~NotTrivialNotTrivial39 ~NotTrivial() { } 40 }; 41 static_assert( std::copyable<NotTrivial> ); 42 43 namespace N1 44 { 45 struct Immovable 46 { 47 Immovable() = default; 48 Immovable(Immovable&&) = delete; 49 }; 50 } 51 static_assert( ! std::copyable<N1::Immovable> ); 52 53 struct Movable 54 { 55 Movable() = default; 56 Movable(Movable&&) = default; 57 Movable& operator=(Movable&&) = default; 58 }; 59 static_assert( ! std::copyable<Movable> ); 60 61 struct MovableAndCopyAssignable 62 { 63 MovableAndCopyAssignable() = default; 64 MovableAndCopyAssignable(MovableAndCopyAssignable&&) = default; 65 MovableAndCopyAssignable& operator=(MovableAndCopyAssignable&&) = default; 66 MovableAndCopyAssignable& operator=(const MovableAndCopyAssignable&) = default; 67 }; 68 static_assert( ! std::copyable<MovableAndCopyAssignable> ); 69 70 struct MovableAndCopyConstructible 71 { 72 MovableAndCopyConstructible() = default; 73 MovableAndCopyConstructible(MovableAndCopyConstructible&&) = default; 74 MovableAndCopyConstructible(const MovableAndCopyConstructible&) = default; 75 MovableAndCopyConstructible& operator=(MovableAndCopyConstructible&&) = default; 76 }; 77 static_assert( ! std::copyable<MovableAndCopyConstructible> ); 78 79 namespace N2 80 { 81 struct Swappable 82 { 83 Swappable() = default; 84 Swappable(Swappable&&) = default; swap(Swappable &,Swappable &)85 friend void swap(Swappable&, Swappable&) { } 86 }; 87 } 88 static_assert( ! std::copyable<N2::Swappable> ); 89 90 struct NotAssignable 91 { 92 NotAssignable() = default; 93 NotAssignable(NotAssignable&&) = default; 94 NotAssignable& operator=(NotAssignable&&) = default; 95 NotAssignable(const NotAssignable&) = default; 96 NotAssignable& operator=(const NotAssignable&) = delete; swap(NotAssignable &,NotAssignable &)97 friend void swap(NotAssignable&, NotAssignable&) { } 98 }; 99 static_assert( ! std::copyable<NotAssignable> ); 100 101 struct NotSwappable 102 { 103 NotSwappable() = default; 104 NotSwappable(const NotSwappable&) = default; 105 NotSwappable& operator=(const NotSwappable&) = default; 106 }; 107 void swap(NotSwappable&, NotSwappable&) = delete; 108 static_assert( std::copyable<NotSwappable> ); // ranges::swap still works! 109