1 //===----------------------------------------------------------------------===// 2 // 3 // The LLVM Compiler Infrastructure 4 // 5 // This file is dual licensed under the MIT and the University of Illinois Open 6 // Source Licenses. See LICENSE.TXT for details. 7 // 8 //===----------------------------------------------------------------------===// 9 10 // <optional> 11 12 // template <class U, class... Args> 13 // constexpr 14 // explicit optional(in_place_t, initializer_list<U> il, Args&&... args); 15 16 #include <experimental/optional> 17 #include <type_traits> 18 #include <vector> 19 #include <cassert> 20 21 #if _LIBCPP_STD_VER > 11 22 23 using std::experimental::optional; 24 using std::experimental::in_place_t; 25 using std::experimental::in_place; 26 27 class X 28 { 29 int i_; 30 int j_ = 0; 31 public: 32 X() : i_(0) {} 33 X(int i) : i_(i) {} 34 X(int i, int j) : i_(i), j_(j) {} 35 36 ~X() {} 37 38 friend bool operator==(const X& x, const X& y) 39 {return x.i_ == y.i_ && x.j_ == y.j_;} 40 }; 41 42 class Y 43 { 44 int i_; 45 int j_ = 0; 46 public: 47 constexpr Y() : i_(0) {} 48 constexpr Y(int i) : i_(i) {} 49 constexpr Y(std::initializer_list<int> il) : i_(il.begin()[0]), j_(il.begin()[1]) {} 50 51 friend constexpr bool operator==(const Y& x, const Y& y) 52 {return x.i_ == y.i_ && x.j_ == y.j_;} 53 }; 54 55 class Z 56 { 57 int i_; 58 int j_ = 0; 59 public: 60 constexpr Z() : i_(0) {} 61 constexpr Z(int i) : i_(i) {} 62 constexpr Z(std::initializer_list<int> il) : i_(il.begin()[0]), j_(il.begin()[1]) 63 {throw 6;} 64 65 friend constexpr bool operator==(const Z& x, const Z& y) 66 {return x.i_ == y.i_ && x.j_ == y.j_;} 67 }; 68 69 70 #endif // _LIBCPP_STD_VER > 11 71 72 int main() 73 { 74 #if _LIBCPP_STD_VER > 11 75 { 76 static_assert(!std::is_constructible<X, std::initializer_list<int>&>::value, ""); 77 static_assert(!std::is_constructible<optional<X>, std::initializer_list<int>&>::value, ""); 78 } 79 { 80 optional<std::vector<int>> opt(in_place, {3, 1}); 81 assert(static_cast<bool>(opt) == true); 82 assert((*opt == std::vector<int>{3, 1})); 83 assert(opt->size() == 2); 84 } 85 { 86 optional<std::vector<int>> opt(in_place, {3, 1}, std::allocator<int>()); 87 assert(static_cast<bool>(opt) == true); 88 assert((*opt == std::vector<int>{3, 1})); 89 assert(opt->size() == 2); 90 } 91 { 92 static_assert(std::is_constructible<optional<Y>, std::initializer_list<int>&>::value, ""); 93 constexpr optional<Y> opt(in_place, {3, 1}); 94 static_assert(static_cast<bool>(opt) == true, ""); 95 static_assert(*opt == Y{3, 1}, ""); 96 97 struct test_constexpr_ctor 98 : public optional<Y> 99 { 100 constexpr test_constexpr_ctor(in_place_t, std::initializer_list<int> i) 101 : optional<Y>(in_place, i) {} 102 }; 103 104 } 105 { 106 static_assert(std::is_constructible<optional<Z>, std::initializer_list<int>&>::value, ""); 107 try 108 { 109 optional<Z> opt(in_place, {3, 1}); 110 assert(false); 111 } 112 catch (int i) 113 { 114 assert(i == 6); 115 } 116 117 struct test_constexpr_ctor 118 : public optional<Z> 119 { 120 constexpr test_constexpr_ctor(in_place_t, std::initializer_list<int> i) 121 : optional<Z>(in_place, i) {} 122 }; 123 124 } 125 #endif // _LIBCPP_STD_VER > 11 126 } 127