[vtk-developers] vtkNew<> (was: Smart pointer declaration macro?)

[Brad King]

David Gobbi wrote:
> This is reply mainly to Brad about vtkLocalPointer<vtkClass>.
> 
> I'm not quite sure why having a smart pointer declaration do a
> allocation is such a bad thing, as long as it is explicit that an
> object is being allocated.  How about if we make the allocation
> explicit in the name of the template, e.g.
> 
> 4. vtkNew<vtkClass> object;
> 
> I know that it appears that the object is being created on the stack,
> but that shouldn't be an issue because the stl container classes use
> heap allocation, too.

Nice!  It's okay if two conditions are satisfied:

  - the allocation is explicit in the name
  - the type is not a smart pointer

If the name "Pointer" is not present then it takes away expectations
of pointer-like operations (e.g. assignment).

I propose a vtkNew<> that is not a subclass of vtkSmartPointer and
has very few operations:

  - default constructor     (allocate & take-reference)
  - arrow operator ->       (access)
  - operator T*             (conversion & raw pointer access)
  - destructor              (deletes reference)

We would specifically disable other operations:

  - no copy constructor
  - no assignment operator=

We could teach vtkSmartPointer<> to construct from vtkNew<>.

A local variable declared with vtkNew<> would create and own one
object for its whole lifetime.  The object will go away on its
destruction unless ownership has been shared by assigning the
object to a real smart pointer.  The exact same class could be
used in place of the vtkNew<> function template I proposed too:

  vtkSmartPointer<vtkBase> o = vtkNew<vtkDerived>();

In this example the RHS expression creates a temporary instance
of the vtkNew<> template.  The vtkSmartPointer<> initialization
takes its own reference to the object before the vtkNew<> template
goes away.

A basic implementation of this vtkNew<> appears below.  It would
just need some tweaking in case the object allocation fails.
This class template is so simple we could consider defining it in
a top-level VTK header so that no sources need to include it.
Alternatively it could be provided in vtkSmartPointer.h.

-Brad


template <class T> class vtkNew
{
public:
  vtkNew(): Object(T::New()) {}
  ~vtkNew() { this->Object->Delete(); }
  T* operator->() const { return this->Object; }
  operator T*() const   { return this->Object; }
private:
  vtkNew(vtkNew<T> const&);         // Not implemented.
  void operator=(vtkNew<T> const&); // Not implemented.
  T* Object;
};

template <class T>
class vtkSmartPointer: public vtkSmartPointerBase
{
  static T* CheckType(T* t) { return t; }
public:
  ...
  template <class U>
  vtkSmartPointer(const vtkNew<U>& r): vtkSmartPointerBase(CheckType(r)) {}
  ...
};