Where Online Learning is simpler!

The C and C++ Include Header Files

cat -n /usr/include/c++/15/bits/allocated_ptr.h

     1	// Guarded Allocation -*- C++ -*-
     2	
     3	// Copyright (C) 2014-2025 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 bits/allocated_ptr.h
    26	 *  This is an internal header file, included by other library headers.
    27	 *  Do not attempt to use it directly. @headername{memory}
    28	 */
    29	
    30	#ifndef _ALLOCATED_PTR_H
    31	#define _ALLOCATED_PTR_H 1
    32	
    33	#if __cplusplus < 201103L
    34	# include <bits/c++0xwarning.h>
    35	#else
    36	# include <type_traits>
    37	# include <bits/ptr_traits.h>
    38	# include <bits/alloc_traits.h>
    39	
    40	namespace std _GLIBCXX_VISIBILITY(default)
    41	{
    42	_GLIBCXX_BEGIN_NAMESPACE_VERSION
    43	/// @cond undocumented
    44	
    45	  /// Non-standard RAII type for managing pointers obtained from allocators.
    46	  template<typename _Alloc>
    47	    struct __allocated_ptr
    48	    {
    49	      using pointer = typename allocator_traits<_Alloc>::pointer;
    50	      using value_type = typename allocator_traits<_Alloc>::value_type;
    51	
    52	      /// Take ownership of __ptr
    53	      __allocated_ptr(_Alloc& __a, pointer __ptr) noexcept
    54	      : _M_alloc(std::__addressof(__a)), _M_ptr(__ptr)
    55	      { }
    56	
    57	      /// Convert __ptr to allocator's pointer type and take ownership of it
    58	      template<typename _Ptr,
    59		       typename _Req = _Require<is_same<_Ptr, value_type*>>>
    60	      __allocated_ptr(_Alloc& __a, _Ptr __ptr)
    61	      : _M_alloc(std::__addressof(__a)),
    62		_M_ptr(pointer_traits<pointer>::pointer_to(*__ptr))
    63	      { }
    64	
    65	      /// Transfer ownership of the owned pointer
    66	      __allocated_ptr(__allocated_ptr&& __gd) noexcept
    67	      : _M_alloc(__gd._M_alloc), _M_ptr(__gd._M_ptr)
    68	      { __gd._M_ptr = nullptr; }
    69	
    70	      /// Deallocate the owned pointer
    71	      ~__allocated_ptr()
    72	      {
    73		if (_M_ptr != nullptr)
    74		  std::allocator_traits<_Alloc>::deallocate(*_M_alloc, _M_ptr, 1);
    75	      }
    76	
    77	      /// Release ownership of the owned pointer
    78	      __allocated_ptr&
    79	      operator=(std::nullptr_t) noexcept
    80	      {
    81		_M_ptr = nullptr;
    82		return *this;
    83	      }
    84	
    85	      explicit operator bool() const noexcept { return (bool)_M_ptr; }
    86	
    87	      /// Get the address that the owned pointer refers to.
    88	      value_type* get() const { return std::__to_address(_M_ptr); }
    89	
    90	      pointer release() { return std::__exchange(_M_ptr, nullptr); }
    91	
    92	    private:
    93	      _Alloc* _M_alloc;
    94	      pointer _M_ptr;
    95	    };
    96	
    97	  /// Allocate space for a single object using __a.
    98	  template<typename _Alloc>
    99	    inline __allocated_ptr<_Alloc>
   100	    __allocate_guarded(_Alloc& __a)
   101	    {
   102	      return { __a, std::allocator_traits<_Alloc>::allocate(__a, 1) };
   103	    }
   104	
   105	  /// RAII type for constructing/destroying an object with an allocated pointer
   106	  template<typename _Alloc>
   107	    struct __allocated_obj : __allocated_ptr<_Alloc>
   108	    {
   109	      using value_type = typename __allocated_ptr<_Alloc>::value_type;
   110	
   111	      __allocated_obj(__allocated_obj<_Alloc>&&) = default;
   112	
   113	      // Default-initialize a value_type at *__ptr
   114	      __allocated_obj(__allocated_ptr<_Alloc>&& __ptr)
   115	      : __allocated_ptr<_Alloc>(std::move(__ptr))
   116	      { ::new ((void*)this->get()) value_type; }
   117	
   118	      // Call the destructor if an object is owned.
   119	      ~__allocated_obj()
   120	      {
   121		if (static_cast<bool>(*this))
   122		  this->get()->~value_type();
   123	      }
   124	
   125	      using __allocated_ptr<_Alloc>::operator=;
   126	
   127	      value_type& operator*() const { return *this->get(); }
   128	      value_type* operator->() const { return this->get(); }
   129	    };
   130	
   131	  /// Construct an object in storage allocated using __a.
   132	  template<typename _Alloc>
   133	    inline __allocated_obj<_Alloc>
   134	    __allocate_guarded_obj(_Alloc& __a)
   135	    {
   136	      return { std::__allocate_guarded(__a) };
   137	    }
   138	
   139	/// @endcond
   140	_GLIBCXX_END_NAMESPACE_VERSION
   141	} // namespace std
   142	
   143	#endif
   144	#endif