L4Re - L4 Runtime Environment
auto_ptr
1 // vim:set ft=cpp: -*- Mode: C++ -*-
2 /*
3  * (c) 2008-2009 Alexander Warg <warg@os.inf.tu-dresden.de>
4  * economic rights: Technische Universit├Ąt Dresden (Germany)
5  *
6  * This file is part of TUD:OS and distributed under the terms of the
7  * GNU General Public License 2.
8  * Please see the COPYING-GPL-2 file for details.
9  *
10  * As a special exception, you may use this file as part of a free software
11  * library without restriction. Specifically, if other files instantiate
12  * templates or use macros or inline functions from this file, or you compile
13  * this file and link it with other files to produce an executable, this
14  * file does not by itself cause the resulting executable to be covered by
15  * the GNU General Public License. This exception does not however
16  * invalidate any other reasons why the executable file might be covered by
17  * the GNU General Public License.
18  */
19 
20 #pragma once
21 
22 namespace cxx {
23 
24 /**
25  * \ingroup cxx_api
26  * \brief Smart pointer with automatic deletion.
27  * \tparam T The type of the referenced object.
28  *
29  * This smart pointer calls the delete operator when the destructor
30  * is called. This has the effect that the object the pointer points to
31  * will be deleted when the pointer goes out of scope, or a new value gets
32  * assigned. The smart pointer provides a release() method to get a normal
33  * pointer to the object and set the smart pointer to NULL.
34  */
35 template< typename T>
36 class Auto_ptr
37 {
38 private:
39  T *_p;
40 
41  struct Priv_type;
42 
43 public:
44  /** \brief The referenced type. */
45  typedef T Ref_type;
46 
47  /**
48  * \brief Construction by assignment of a normal pointer.
49  * \param p The pointer to the object
50  */
51  explicit Auto_ptr(T *p = 0) throw() : _p(p) {}
52 
53  /**
54  * \brief Copy construction, releases the original pointer.
55  * \param o The smart pointer, which shall be copied and released.
56  */
57  Auto_ptr(Auto_ptr const &o) throw()
58  : _p(const_cast<Auto_ptr<T>&>(o).release())
59  {}
60 
61  /**
62  * \brief Assignment from another smart pointer.
63  * \param o The source for the assignment (will be released).
64  */
65  Auto_ptr &operator = (Auto_ptr const &o) throw()
66  {
67  if (&o != this)
68  {
69  if (_p) delete _p;
70  _p = const_cast<Auto_ptr<T>&>(o).release();
71  }
72  return *this;
73  }
74 
75  /** \brief Destruction, shall delete the object. */
76  ~Auto_ptr() throw()
77  { if (_p) delete _p; }
78 
79  /** \brief Dereference the pointer. */
80  T &operator * () const throw() { return *_p; }
81 
82  /** \brief Member access for the object. */
83  T *operator -> () const throw() { return _p; }
84 
85  /**
86  * \brief Get the normal pointer.
87  * \attention This function will not release the object, the
88  * object will be deleted by the smart pointer.
89  */
90  T *get() const throw() { return _p; }
91 
92  /**
93  * \brief Release the object and get the normal pointer back.
94  *
95  * After calling this function the smart pointer will point to NULL
96  * and the object will not be deleted by the pointer anymore.
97  */
98  T *release() throw() { T *t = _p; _p = 0; return t; }
99 
100  /**
101  * \brief Delete the object and reset the smart pointer to NULL.
102  */
103  void reset(T *p = 0) throw()
104  {
105  if (_p) delete _p;
106  _p = p;
107  }
108 
109  /** \brief Operator for `if (!ptr) ...`. */
110  operator Priv_type * () const throw()
111  { return reinterpret_cast<Priv_type*>(_p); }
112 };
113 }