1 2 namespace __gnu_cxx { 3 template <typename T> 4 struct basic_iterator { 5 basic_iterator operator++(); 6 T& operator*() const; 7 T* operator->() const; 8 }; 9 10 template<typename T> 11 bool operator!=(basic_iterator<T>, basic_iterator<T>); 12 } 13 14 namespace std { 15 template<typename T> struct remove_reference { typedef T type; }; 16 template<typename T> struct remove_reference<T &> { typedef T type; }; 17 template<typename T> struct remove_reference<T &&> { typedef T type; }; 18 19 template<typename T> 20 typename remove_reference<T>::type &&move(T &&t) noexcept; 21 22 template <typename C> 23 auto data(const C &c) -> decltype(c.data()); 24 25 template <typename C> 26 auto begin(C &c) -> decltype(c.begin()); 27 28 template<typename T, int N> 29 T *begin(T (&array)[N]); 30 31 using size_t = decltype(sizeof(0)); 32 33 template<typename T> 34 struct initializer_list { 35 const T* ptr; size_t sz; 36 }; 37 template<typename T> class allocator {}; 38 template <typename T, typename Alloc = allocator<T>> 39 struct vector { 40 typedef __gnu_cxx::basic_iterator<T> iterator; 41 iterator begin(); 42 iterator end(); 43 const T *data() const; 44 vector(); 45 vector(initializer_list<T> __l, 46 const Alloc& alloc = Alloc()); 47 48 template<typename InputIterator> 49 vector(InputIterator first, InputIterator __last); 50 51 T &at(int n); 52 53 void push_back(const T&); 54 void push_back(T&&); 55 const T& back() const; 56 void insert(iterator, T&&); 57 }; 58 59 template<typename T> 60 struct basic_string_view { 61 basic_string_view(); 62 basic_string_view(const T *); 63 const T *begin() const; 64 }; 65 using string_view = basic_string_view<char>; 66 67 template<class _Mystr> struct iter { 68 iter& operator-=(int); 69 70 iter operator-(int _Off) const { 71 iter _Tmp = *this; 72 return _Tmp -= _Off; 73 } 74 }; 75 76 template<typename T> 77 struct basic_string { 78 basic_string(); 79 basic_string(const T *); 80 const T *c_str() const; 81 operator basic_string_view<T> () const; 82 using const_iterator = iter<T>; 83 }; 84 using string = basic_string<char>; 85 86 template<typename T> 87 struct unique_ptr { 88 T &operator*(); 89 T *get() const; 90 }; 91 92 template<typename T> 93 struct optional { 94 optional(); 95 optional(const T&); 96 97 template<typename U = T> 98 optional(U&& t); 99 100 template<typename U> 101 optional(optional<U>&& __t); 102 103 T &operator*() &; 104 T &&operator*() &&; 105 T &value() &; 106 T &&value() &&; 107 }; 108 template<typename T> 109 optional<__decay(T)> make_optional(T&&); 110 111 112 template<typename T> 113 struct stack { 114 T &top(); 115 }; 116 117 struct any {}; 118 119 template<typename T> 120 T any_cast(const any& operand); 121 122 template<typename T> 123 struct reference_wrapper { 124 template<typename U> 125 reference_wrapper(U &&); 126 }; 127 128 template<typename T> 129 reference_wrapper<T> ref(T& t) noexcept; 130 131 template <typename T> 132 struct [[gsl::Pointer]] iterator { 133 T& operator*() const; 134 }; 135 136 struct false_type { 137 static constexpr bool value = false; 138 constexpr operator bool() const noexcept { return value; } 139 }; 140 struct true_type { 141 static constexpr bool value = true; 142 constexpr operator bool() const noexcept { return value; } 143 }; 144 145 template<class T> struct is_pointer : false_type {}; 146 template<class T> struct is_pointer<T*> : true_type {}; 147 template<class T> struct is_pointer<T* const> : true_type {}; 148 } 149