Where Online Learning is simpler!
The C and C++ Include Header Files
/usr/include/c++/11/array
$ cat -n /usr/include/c++/11/array 1 // <array> -*- C++ -*- 2 3 // Copyright (C) 2007-2021 Free Software Foundation, Inc. 4 // 5 // This file is part of the GNU ISO C++ Library. This library is free 6 // software; you can redistribute it and/or modify it under the 7 // terms of the GNU General Public License as published by the 8 // Free Software Foundation; either version 3, or (at your option) 9 // any later version. 10 11 // This library is distributed in the hope that it will be useful, 12 // but WITHOUT ANY WARRANTY; without even the implied warranty of 13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 // GNU General Public License for more details. 15 16 // Under Section 7 of GPL version 3, you are granted additional 17 // permissions described in the GCC Runtime Library Exception, version 18 // 3.1, as published by the Free Software Foundation. 19 20 // You should have received a copy of the GNU General Public License and 21 // a copy of the GCC Runtime Library Exception along with this program; 22 // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see 23 // <http://www.gnu.org/licenses/>. 24 25 /** @file include/array 26 * This is a Standard C++ Library header. 27 */ 28 29 #ifndef _GLIBCXX_ARRAY 30 #define _GLIBCXX_ARRAY 1 31 32 #pragma GCC system_header 33 34 #if __cplusplus < 201103L 35 # include <bits/c++0x_warning.h> 36 #else 37 38 #include <utility> 39 #include <bits/functexcept.h> 40 #include <bits/stl_algobase.h> 41 #include <bits/range_access.h> 42 #include <debug/assertions.h> 43 44 namespace std _GLIBCXX_VISIBILITY(default) 45 { 46 _GLIBCXX_BEGIN_NAMESPACE_VERSION 47 48 template<typename _Tp, std::size_t _Nm> 49 struct __array_traits 50 { 51 typedef _Tp _Type[_Nm]; 52 typedef __is_swappable<_Tp> _Is_swappable; 53 typedef __is_nothrow_swappable<_Tp> _Is_nothrow_swappable; 54 55 static constexpr _Tp& 56 _S_ref(const _Type& __t, std::size_t __n) noexcept 57 { return const_cast<_Tp&>(__t[__n]); } 58 59 static constexpr _Tp* 60 _S_ptr(const _Type& __t) noexcept 61 { return const_cast<_Tp*>(__t); } 62 }; 63 64 template<typename _Tp> 65 struct __array_traits<_Tp, 0> 66 { 67 struct _Type { }; 68 typedef true_type _Is_swappable; 69 typedef true_type _Is_nothrow_swappable; 70 71 static constexpr _Tp& 72 _S_ref(const _Type&, std::size_t) noexcept 73 { return *static_cast<_Tp*>(nullptr); } 74 75 static constexpr _Tp* 76 _S_ptr(const _Type&) noexcept 77 { return nullptr; } 78 }; 79 80 /** 81 * @brief A standard container for storing a fixed size sequence of elements. 82 * 83 * @ingroup sequences 84 * 85 * Meets the requirements of a <a href="tables.html#65">container</a>, a 86 * <a href="tables.html#66">reversible container</a>, and a 87 * <a href="tables.html#67">sequence</a>. 88 * 89 * Sets support random access iterators. 90 * 91 * @tparam Tp Type of element. Required to be a complete type. 92 * @tparam Nm Number of elements. 93 */ 94 template<typename _Tp, std::size_t _Nm> 95 struct array 96 { 97 typedef _Tp value_type; 98 typedef value_type* pointer; 99 typedef const value_type* const_pointer; 100 typedef value_type& reference; 101 typedef const value_type& const_reference; 102 typedef value_type* iterator; 103 typedef const value_type* const_iterator; 104 typedef std::size_t size_type; 105 typedef std::ptrdiff_t difference_type; 106 typedef std::reverse_iterator<iterator> reverse_iterator; 107 typedef std::reverse_iterator<const_iterator> const_reverse_iterator; 108 109 // Support for zero-sized arrays mandatory. 110 typedef __array_traits<_Tp, _Nm> _AT_Type; 111 typename _AT_Type::_Type _M_elems; 112 113 // No explicit construct/copy/destroy for aggregate type. 114 115 // DR 776. 116 _GLIBCXX20_CONSTEXPR void 117 fill(const value_type& __u) 118 { std::fill_n(begin(), size(), __u); } 119 120 _GLIBCXX20_CONSTEXPR void 121 swap(array& __other) 122 noexcept(_AT_Type::_Is_nothrow_swappable::value) 123 { std::swap_ranges(begin(), end(), __other.begin()); } 124 125 // Iterators. 126 _GLIBCXX17_CONSTEXPR iterator 127 begin() noexcept 128 { return iterator(data()); } 129 130 _GLIBCXX17_CONSTEXPR const_iterator 131 begin() const noexcept 132 { return const_iterator(data()); } 133 134 _GLIBCXX17_CONSTEXPR iterator 135 end() noexcept 136 { return iterator(data() + _Nm); } 137 138 _GLIBCXX17_CONSTEXPR const_iterator 139 end() const noexcept 140 { return const_iterator(data() + _Nm); } 141 142 _GLIBCXX17_CONSTEXPR reverse_iterator 143 rbegin() noexcept 144 { return reverse_iterator(end()); } 145 146 _GLIBCXX17_CONSTEXPR const_reverse_iterator 147 rbegin() const noexcept 148 { return const_reverse_iterator(end()); } 149 150 _GLIBCXX17_CONSTEXPR reverse_iterator 151 rend() noexcept 152 { return reverse_iterator(begin()); } 153 154 _GLIBCXX17_CONSTEXPR const_reverse_iterator 155 rend() const noexcept 156 { return const_reverse_iterator(begin()); } 157 158 _GLIBCXX17_CONSTEXPR const_iterator 159 cbegin() const noexcept 160 { return const_iterator(data()); } 161 162 _GLIBCXX17_CONSTEXPR const_iterator 163 cend() const noexcept 164 { return const_iterator(data() + _Nm); } 165 166 _GLIBCXX17_CONSTEXPR const_reverse_iterator 167 crbegin() const noexcept 168 { return const_reverse_iterator(end()); } 169 170 _GLIBCXX17_CONSTEXPR const_reverse_iterator 171 crend() const noexcept 172 { return const_reverse_iterator(begin()); } 173 174 // Capacity. 175 constexpr size_type 176 size() const noexcept { return _Nm; } 177 178 constexpr size_type 179 max_size() const noexcept { return _Nm; } 180 181 _GLIBCXX_NODISCARD constexpr bool 182 empty() const noexcept { return size() == 0; } 183 184 // Element access. 185 _GLIBCXX17_CONSTEXPR reference 186 operator[](size_type __n) noexcept 187 { 188 __glibcxx_requires_subscript(__n); 189 return _AT_Type::_S_ref(_M_elems, __n); 190 } 191 192 constexpr const_reference 193 operator[](size_type __n) const noexcept 194 { 195 #if __cplusplus >= 201402L 196 __glibcxx_requires_subscript(__n); 197 #endif 198 return _AT_Type::_S_ref(_M_elems, __n); 199 } 200 201 _GLIBCXX17_CONSTEXPR reference 202 at(size_type __n) 203 { 204 if (__n >= _Nm) 205 std::__throw_out_of_range_fmt(__N("array::at: __n (which is %zu) " 206 ">= _Nm (which is %zu)"), 207 __n, _Nm); 208 return _AT_Type::_S_ref(_M_elems, __n); 209 } 210 211 constexpr const_reference 212 at(size_type __n) const 213 { 214 // Result of conditional expression must be an lvalue so use 215 // boolean ? lvalue : (throw-expr, lvalue) 216 return __n < _Nm ? _AT_Type::_S_ref(_M_elems, __n) 217 : (std::__throw_out_of_range_fmt(__N("array::at: __n (which is %zu) " 218 ">= _Nm (which is %zu)"), 219 __n, _Nm), 220 _AT_Type::_S_ref(_M_elems, 0)); 221 } 222 223 _GLIBCXX17_CONSTEXPR reference 224 front() noexcept 225 { 226 __glibcxx_requires_nonempty(); 227 return *begin(); 228 } 229 230 constexpr const_reference 231 front() const noexcept 232 { 233 #if __cplusplus >= 201402L 234 __glibcxx_requires_nonempty(); 235 #endif 236 return _AT_Type::_S_ref(_M_elems, 0); 237 } 238 239 _GLIBCXX17_CONSTEXPR reference 240 back() noexcept 241 { 242 __glibcxx_requires_nonempty(); 243 return _Nm ? *(end() - 1) : *end(); 244 } 245 246 constexpr const_reference 247 back() const noexcept 248 { 249 #if __cplusplus >= 201402L 250 __glibcxx_requires_nonempty(); 251 #endif 252 return _Nm ? _AT_Type::_S_ref(_M_elems, _Nm - 1) 253 : _AT_Type::_S_ref(_M_elems, 0); 254 } 255 256 _GLIBCXX17_CONSTEXPR pointer 257 data() noexcept 258 { return _AT_Type::_S_ptr(_M_elems); } 259 260 _GLIBCXX17_CONSTEXPR const_pointer 261 data() const noexcept 262 { return _AT_Type::_S_ptr(_M_elems); } 263 }; 264 265 #if __cpp_deduction_guides >= 201606 266 template<typename _Tp, typename... _Up> 267 array(_Tp, _Up...) 268 -> array<enable_if_t<(is_same_v<_Tp, _Up> && ...), _Tp>, 269 1 + sizeof...(_Up)>; 270 #endif 271 272 // Array comparisons. 273 template<typename _Tp, std::size_t _Nm> 274 _GLIBCXX20_CONSTEXPR 275 inline bool 276 operator==(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two) 277 { return std::equal(__one.begin(), __one.end(), __two.begin()); } 278 279 #if __cpp_lib_three_way_comparison && __cpp_lib_concepts 280 template<typename _Tp, size_t _Nm> 281 constexpr __detail::__synth3way_t<_Tp> 282 operator<=>(const array<_Tp, _Nm>& __a, const array<_Tp, _Nm>& __b) 283 { 284 #ifdef __cpp_lib_is_constant_evaluated 285 if constexpr (_Nm && __is_memcmp_ordered<_Tp>::__value) 286 if (!std::is_constant_evaluated()) 287 { 288 constexpr size_t __n = _Nm * sizeof(_Tp); 289 return __builtin_memcmp(__a.data(), __b.data(), __n) <=> 0; 290 } 291 #endif 292 293 for (size_t __i = 0; __i < _Nm; ++__i) 294 { 295 auto __c = __detail::__synth3way(__a[__i], __b[__i]); 296 if (__c != 0) 297 return __c; 298 } 299 return strong_ordering::equal; 300 } 301 #else 302 template<typename _Tp, std::size_t _Nm> 303 _GLIBCXX20_CONSTEXPR 304 inline bool 305 operator!=(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two) 306 { return !(__one == __two); } 307 308 template<typename _Tp, std::size_t _Nm> 309 _GLIBCXX20_CONSTEXPR 310 inline bool 311 operator<(const array<_Tp, _Nm>& __a, const array<_Tp, _Nm>& __b) 312 { 313 return std::lexicographical_compare(__a.begin(), __a.end(), 314 __b.begin(), __b.end()); 315 } 316 317 template<typename _Tp, std::size_t _Nm> 318 _GLIBCXX20_CONSTEXPR 319 inline bool 320 operator>(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two) 321 { return __two < __one; } 322 323 template<typename _Tp, std::size_t _Nm> 324 _GLIBCXX20_CONSTEXPR 325 inline bool 326 operator<=(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two) 327 { return !(__one > __two); } 328 329 template<typename _Tp, std::size_t _Nm> 330 _GLIBCXX20_CONSTEXPR 331 inline bool 332 operator>=(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two) 333 { return !(__one < __two); } 334 #endif // three_way_comparison && concepts 335 336 // Specialized algorithms. 337 template<typename _Tp, std::size_t _Nm> 338 _GLIBCXX20_CONSTEXPR 339 inline 340 #if __cplusplus > 201402L || !defined(__STRICT_ANSI__) // c++1z or gnu++11 341 // Constrained free swap overload, see p0185r1 342 typename enable_if< 343 __array_traits<_Tp, _Nm>::_Is_swappable::value 344 >::type 345 #else 346 void 347 #endif 348 swap(array<_Tp, _Nm>& __one, array<_Tp, _Nm>& __two) 349 noexcept(noexcept(__one.swap(__two))) 350 { __one.swap(__two); } 351 352 #if __cplusplus > 201402L || !defined(__STRICT_ANSI__) // c++1z or gnu++11 353 template<typename _Tp, std::size_t _Nm> 354 typename enable_if< 355 !__array_traits<_Tp, _Nm>::_Is_swappable::value>::type 356 swap(array<_Tp, _Nm>&, array<_Tp, _Nm>&) = delete; 357 #endif 358 359 template<std::size_t _Int, typename _Tp, std::size_t _Nm> 360 constexpr _Tp& 361 get(array<_Tp, _Nm>& __arr) noexcept 362 { 363 static_assert(_Int < _Nm, "array index is within bounds"); 364 return __array_traits<_Tp, _Nm>::_S_ref(__arr._M_elems, _Int); 365 } 366 367 template<std::size_t _Int, typename _Tp, std::size_t _Nm> 368 constexpr _Tp&& 369 get(array<_Tp, _Nm>&& __arr) noexcept 370 { 371 static_assert(_Int < _Nm, "array index is within bounds"); 372 return std::move(std::get<_Int>(__arr)); 373 } 374 375 template<std::size_t _Int, typename _Tp, std::size_t _Nm> 376 constexpr const _Tp& 377 get(const array<_Tp, _Nm>& __arr) noexcept 378 { 379 static_assert(_Int < _Nm, "array index is within bounds"); 380 return __array_traits<_Tp, _Nm>::_S_ref(__arr._M_elems, _Int); 381 } 382 383 template<std::size_t _Int, typename _Tp, std::size_t _Nm> 384 constexpr const _Tp&& 385 get(const array<_Tp, _Nm>&& __arr) noexcept 386 { 387 static_assert(_Int < _Nm, "array index is within bounds"); 388 return std::move(std::get<_Int>(__arr)); 389 } 390 391 #if __cplusplus > 201703L 392 #define __cpp_lib_to_array 201907L 393 394 template<bool _Move = false, typename _Tp, size_t... _Idx> 395 constexpr array<remove_cv_t<_Tp>, sizeof...(_Idx)> 396 __to_array(_Tp (&__a)[sizeof...(_Idx)], index_sequence<_Idx...>) 397 { 398 if constexpr (_Move) 399 return {{std::move(__a[_Idx])...}}; 400 else 401 return {{__a[_Idx]...}}; 402 } 403 404 template<typename _Tp, size_t _Nm> 405 constexpr array<remove_cv_t<_Tp>, _Nm> 406 to_array(_Tp (&__a)[_Nm]) 407 noexcept(is_nothrow_constructible_v<_Tp, _Tp&>) 408 { 409 static_assert(!is_array_v<_Tp>); 410 static_assert(is_constructible_v<_Tp, _Tp&>); 411 if constexpr (is_constructible_v<_Tp, _Tp&>) 412 return std::__to_array(__a, make_index_sequence<_Nm>{}); 413 __builtin_unreachable(); // FIXME: see PR c++/91388 414 } 415 416 template<typename _Tp, size_t _Nm> 417 constexpr array<remove_cv_t<_Tp>, _Nm> 418 to_array(_Tp (&&__a)[_Nm]) 419 noexcept(is_nothrow_move_constructible_v<_Tp>) 420 { 421 static_assert(!is_array_v<_Tp>); 422 static_assert(is_move_constructible_v<_Tp>); 423 if constexpr (is_move_constructible_v<_Tp>) 424 return std::__to_array<1>(__a, make_index_sequence<_Nm>{}); 425 __builtin_unreachable(); // FIXME: see PR c++/91388 426 } 427 #endif // C++20 428 429 // Tuple interface to class template array. 430 431 /// tuple_size 432 template<typename _Tp> 433 struct tuple_size; 434 435 /// Partial specialization for std::array 436 template<typename _Tp, std::size_t _Nm> 437 struct tuple_size<array<_Tp, _Nm>> 438 : public integral_constant<std::size_t, _Nm> { }; 439 440 /// tuple_element 441 template<std::size_t _Int, typename _Tp> 442 struct tuple_element; 443 444 /// Partial specialization for std::array 445 template<std::size_t _Int, typename _Tp, std::size_t _Nm> 446 struct tuple_element<_Int, array<_Tp, _Nm>> 447 { 448 static_assert(_Int < _Nm, "index is out of bounds"); 449 typedef _Tp type; 450 }; 451 452 template<typename _Tp, std::size_t _Nm> 453 struct __is_tuple_like_impl<array<_Tp, _Nm>> : true_type 454 { }; 455 456 _GLIBCXX_END_NAMESPACE_VERSION 457 } // namespace std 458 459 #endif // C++11 460 461 #endif // _GLIBCXX_ARRAY
Contact us
|
About us
|
Term of use
|
Copyright © 2000-2025 MyWebUniversity.com ™
