*/
SmartPointer(const SmartPointer<T, P> &tt);
+ /**
+ * Move constructor for SmartPointer.
+ */
+ SmartPointer(SmartPointer<T, P> &&tt) noexcept;
+
/**
* Constructor taking a normal pointer. If possible, i.e. if the pointer is
* not a null pointer, the constructor subscribes to the given object to
SmartPointer<T, P> &
operator=(const SmartPointer<T, P> &tt);
+ /**
+ * Move assignment operator for SmartPointer.
+ */
+ SmartPointer<T, P> &
+ operator=(SmartPointer<T, P> &&tt) noexcept;
+
/**
* Delete the object pointed to and set the pointer to nullptr. Note
* that unlike what the documentation of the class describes, *this
+template <typename T, typename P>
+inline SmartPointer<T, P>::SmartPointer(SmartPointer<T, P> &&tt) noexcept
+ : t(tt.t)
+ , id(tt.id)
+ , pointed_to_object_is_alive(false)
+{
+ if (tt.pointed_to_object_is_alive && t != nullptr)
+ t->subscribe(&pointed_to_object_is_alive, id);
+
+ // Release the rhs object as if we had moved all members away from
+ // it directly:
+ tt = nullptr;
+}
+
+
+
template <typename T, typename P>
inline SmartPointer<T, P>::~SmartPointer()
{
+template <typename T, typename P>
+inline SmartPointer<T, P> &
+SmartPointer<T, P>::operator=(SmartPointer<T, P> &&tt) noexcept
+{
+ // if objects on the left and right hand side of the operator= are
+ // the same, then this is a no-op
+ if (&tt != this)
+ {
+ // Let us unsubscribe from the current object
+ if (pointed_to_object_is_alive && t != nullptr)
+ t->unsubscribe(&pointed_to_object_is_alive, id);
+
+ // Then reset to the new object, and subscribe to it, assuming
+ // that the the rhs points to anything in the first place:
+ if (tt.pointed_to_object_is_alive && tt != nullptr)
+ {
+ t = tt.get();
+ t->subscribe(&pointed_to_object_is_alive, id);
+ }
+ else
+ t = nullptr;
+
+ // Finally release the rhs object since we moved its contents
+ tt = nullptr;
+ }
+ return *this;
+}
+
+
+
template <typename T, typename P>
inline SmartPointer<T, P>::operator T *() const
{