STLdoc
STLdocumentation
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
Functions
auto_ptr.h File Reference
#include <bits/c++config.h>
#include <debug/debug.h>

Go to the source code of this file.

Functions

namespace std _GLIBCXX_VISIBILITY (default)
 

Detailed Description

This is an internal header file, included by other library headers. Do not attempt to use it directly. {memory}

Function Documentation

namespace std _GLIBCXX_VISIBILITY ( default  )

A wrapper class to provide auto_ptr with reference semantics. For example, an auto_ptr can be assigned (or constructed from) the result of a function which returns an auto_ptr by value.

All the auto_ptr_ref stuff should happen behind the scenes.

A simple smart pointer providing strict ownership semantics.

The Standard says:

An auto_ptr owns the object it holds a pointer to.  Copying
an auto_ptr copies the pointer and transfers ownership to the
destination.  If more than one auto_ptr owns the same object
at the same time the behavior of the program is undefined.
The uses of auto_ptr include providing temporary
exception-safety for dynamically allocated memory, passing
ownership of dynamically allocated memory to a function, and
returning dynamically allocated memory from a function.  auto_ptr does not meet the CopyConstructible and Assignable
requirements for Standard Library container elements and thus
instantiating a Standard Library container with an auto_ptr results in undefined behavior.

Quoted from [20.4.5]/3.

Good examples of what can and cannot be done with auto_ptr can be found in the libstdc++ testsuite.

_GLIBCXX_RESOLVE_LIB_DEFECTS

  1. auto_ptr<> conversion issues These resolutions have all been incorporated.

The pointed-to type.

An auto_ptr is usually constructed from a raw pointer.

Parameters
__pA pointer (defaults to NULL).

This object now owns the object pointed to by __p.

An auto_ptr can be constructed from another auto_ptr.

Parameters
__aAnother auto_ptr of the same type.

This object now owns the object previously owned by __a, which has given up ownership.

An auto_ptr can be constructed from another auto_ptr.

Parameters
__aAnother auto_ptr of a different but related type.

A pointer-to-Tp1 must be convertible to a pointer-to-Tp/element_type.

This object now owns the object previously owned by __a, which has given up ownership.

auto_ptr assignment operator.

Parameters
__aAnother auto_ptr of the same type.

This object now owns the object previously owned by __a, which has given up ownership. The object that this one used to own and track has been deleted.

auto_ptr assignment operator.

Parameters
__aAnother auto_ptr of a different but related type.

A pointer-to-Tp1 must be convertible to a pointer-to-Tp/element_type.

This object now owns the object previously owned by __a, which has given up ownership. The object that this one used to own and track has been deleted.

When the auto_ptr goes out of scope, the object it owns is deleted. If it no longer owns anything (i.e., get() is NULL), then this has no effect.

The C++ standard says there is supposed to be an empty throw specification here, but omitting it is standard conforming. Its presence can be detected only if _Tp::~_Tp() throws, but this is prohibited. [17.4.3.6]/2

Smart pointer dereferencing.

If this auto_ptr no longer owns anything, then this operation will crash. (For a smart pointer, no longer owns anything is the same as being a null pointer, and you know what happens when you dereference one of those...)

Smart pointer dereferencing.

This returns the pointer itself, which the language then will automatically cause to be dereferenced.

Bypassing the smart pointer.

Returns
The raw pointer being managed.

You can get a copy of the pointer that this object owns, for situations such as passing to a function which only accepts a raw pointer.

Note
This auto_ptr still owns the memory.

Bypassing the smart pointer.

Returns
The raw pointer being managed.

You can get a copy of the pointer that this object owns, for situations such as passing to a function which only accepts a raw pointer.

Note
This auto_ptr no longer owns the memory. When this object goes out of scope, nothing will happen.

Forcibly deletes the managed object.

Parameters
__pA pointer (defaults to NULL).

This object now owns the object pointed to by __p. The previous object has been deleted.

Automatic conversions

These operations convert an auto_ptr into and from an auto_ptr_ref automatically as needed. This allows constructs such as

auto_ptr<Derived> func_returning_auto_ptr(.....);
...
auto_ptr<Base> ptr = func_returning_auto_ptr(.....);
37 {
38 _GLIBCXX_BEGIN_NAMESPACE_VERSION
39 
47  template<typename _Tp1>
48  struct auto_ptr_ref
49  {
50  _Tp1* _M_ptr;
51 
52  explicit
53  auto_ptr_ref(_Tp1* __p): _M_ptr(__p) { }
54  } _GLIBCXX_DEPRECATED;
55 
56 
86  template<typename _Tp>
87  class auto_ptr
88  {
89  private:
90  _Tp* _M_ptr;
91 
92  public:
94  typedef _Tp element_type;
95 
102  explicit
103  auto_ptr(element_type* __p = 0) throw() : _M_ptr(__p) { }
104 
112  auto_ptr(auto_ptr& __a) throw() : _M_ptr(__a.release()) { }
113 
124  template<typename _Tp1>
125  auto_ptr(auto_ptr<_Tp1>& __a) throw() : _M_ptr(__a.release()) { }
126 
135  auto_ptr&
136  operator=(auto_ptr& __a) throw()
137  {
138  reset(__a.release());
139  return *this;
140  }
141 
152  template<typename _Tp1>
153  auto_ptr&
154  operator=(auto_ptr<_Tp1>& __a) throw()
155  {
156  reset(__a.release());
157  return *this;
158  }
159 
170  ~auto_ptr() { delete _M_ptr; }
171 
180  element_type&
181  operator*() const throw()
182  {
183  _GLIBCXX_DEBUG_ASSERT(_M_ptr != 0);
184  return *_M_ptr;
185  }
186 
193  element_type*
194  operator->() const throw()
195  {
196  _GLIBCXX_DEBUG_ASSERT(_M_ptr != 0);
197  return _M_ptr;
198  }
199 
210  element_type*
211  get() const throw() { return _M_ptr; }
212 
224  element_type*
225  release() throw()
226  {
227  element_type* __tmp = _M_ptr;
228  _M_ptr = 0;
229  return __tmp;
230  }
231 
239  void
240  reset(element_type* __p = 0) throw()
241  {
242  if (__p != _M_ptr)
243  {
244  delete _M_ptr;
245  _M_ptr = __p;
246  }
247  }
248 
260  auto_ptr(auto_ptr_ref<element_type> __ref) throw()
261  : _M_ptr(__ref._M_ptr) { }
262 
263  auto_ptr&
264  operator=(auto_ptr_ref<element_type> __ref) throw()
265  {
266  if (__ref._M_ptr != this->get())
267  {
268  delete _M_ptr;
269  _M_ptr = __ref._M_ptr;
270  }
271  return *this;
272  }
273 
274  template<typename _Tp1>
275  operator auto_ptr_ref<_Tp1>() throw()
276  { return auto_ptr_ref<_Tp1>(this->release()); }
277 
278  template<typename _Tp1>
279  operator auto_ptr<_Tp1>() throw()
280  { return auto_ptr<_Tp1>(this->release()); }
281  } _GLIBCXX_DEPRECATED;
282 
283  // _GLIBCXX_RESOLVE_LIB_DEFECTS
284  // 541. shared_ptr template assignment and void
285  template<>
286  class auto_ptr<void>
287  {
288  public:
289  typedef void element_type;
290  } _GLIBCXX_DEPRECATED;
291 
292 #if __cplusplus >= 201103L
293  template<_Lock_policy _Lp>
294  template<typename _Tp>
295  inline
296  __shared_count<_Lp>::__shared_count(std::auto_ptr<_Tp>&& __r)
297  : _M_pi(new _Sp_counted_ptr<_Tp*, _Lp>(__r.get()))
298  { __r.release(); }
299 
300  template<typename _Tp, _Lock_policy _Lp>
301  template<typename _Tp1>
302  inline
303  __shared_ptr<_Tp, _Lp>::__shared_ptr(std::auto_ptr<_Tp1>&& __r)
304  : _M_ptr(__r.get()), _M_refcount()
305  {
306  __glibcxx_function_requires(_ConvertibleConcept<_Tp1*, _Tp*>)
307  static_assert( sizeof(_Tp1) > 0, "incomplete type" );
308  _Tp1* __tmp = __r.get();
309  _M_refcount = __shared_count<_Lp>(std::move(__r));
310  __enable_shared_from_this_helper(_M_refcount, __tmp, __tmp);
311  }
312 
313  template<typename _Tp>
314  template<typename _Tp1>
315  inline
316  shared_ptr<_Tp>::shared_ptr(std::auto_ptr<_Tp1>&& __r)
317  : __shared_ptr<_Tp>(std::move(__r)) { }
318 
319  template<typename _Tp, typename _Dp>
320  template<typename _Up, typename>
321  inline
322  unique_ptr<_Tp, _Dp>::unique_ptr(auto_ptr<_Up>&& __u) noexcept
323  : _M_t(__u.release(), deleter_type()) { }
324 #endif
325 
326 _GLIBCXX_END_NAMESPACE_VERSION
327 } // namespace
#define __glibcxx_function_requires(...)
Definition: concept_check.h:47
#define _GLIBCXX_DEBUG_ASSERT(_Condition)
Definition: debug.h:61