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

[David Gobbi]

Thanks, that helps me understand the difference.  By removing
assignment, you get some extra safety because when you declare the
variable "reader", no-one can assign it to a different object.  In
other words, it doesn't behave like a pointer with regards to
assignment.  I like that.

  David

On Thu, Jan 28, 2010 at 3:31 PM, pat marion <pat.marion at kitware.com> wrote:
> The main difference between vtkNew and vtkSmartPointer is: vtkNew has
> no assignment operator or copy constructor.  Removing these features
> makes you think about vtkNew in a different way than vtkSmartPointer.
> Quoting from Brad:
>
>  A local variable declared with vtkNew<> would create and own one
> object for its whole lifetime.
>
>
> Here is an example using both:
>
>
> vtkSmartPointer<vtkPolyData> output; // null, no instance allocated
>
> if (extension == ".stl")
>  {
>  vtkNew<vtkSTLReader> reader; // instance constructed
>  reader->SetFileName(filename);
>  reader->Update();
>  output = reader->GetOutput();
>  }
> else if (extension = ".vtk")
>  {
>  vtkNew<vtkPolyDataReader> reader; // instance constructed
>  reader->SetFileName(filename);
>  reader->Update();
>  output = reader->GetOutput();
>  }
>
> if (readerOutput)
>  {
>  cout << "Number of points read:" << readerOutput->GetNumberOfPoints();
>  }
>
>
> Pat
>
> On Thu, Jan 28, 2010 at 5:07 PM, David Gobbi <david.gobbi at gmail.com> wrote:
>> Bill,
>>
>> Yup, that's exactly how it would be used.  It's essentially Marcus'
>> original proposal, but re-named and no longer derived from
>> vtkSmartPointer in order to avoid certain gotcha's that Brad explained
>> but which I didn't fully understand.
>>
>>   David
>>
>>
>> On Thu, Jan 28, 2010 at 2:56 PM, Bill Lorensen <bill.lorensen at gmail.com> wrote:
>>> I admit I don't understand the "how", but the "what" looks great.
>>>
>>> So,
>>> instead of:
>>>
>>> vtkSmartPointer<vtkImageRectilinearWipe> wipe =
>>>  vtkSmartPointer<vtkImageRectilinearWipe>::New();
>>>
>>> it would be what?
>>> vtkNew<vtkImageRectilinearWipe> wipe;
>>>
>>>
>>> On Thu, Jan 28, 2010 at 4:41 PM, Brad King <brad.king at kitware.com> wrote:
>>>> 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)) {}
>>>>  ...
>>>> };
>>>> _______________________________________________
>>>> Powered by www.kitware.com
>>>>
>>>> Visit other Kitware open-source projects at http://www.kitware.com/opensource/opensource.html
>>>>
>>>> Follow this link to subscribe/unsubscribe:
>>>> http://www.vtk.org/mailman/listinfo/vtk-developers
>>>>
>>>>
>>>
>> _______________________________________________
>> Powered by www.kitware.com
>>
>> Visit other Kitware open-source projects at http://www.kitware.com/opensource/opensource.html
>>
>> Follow this link to subscribe/unsubscribe:
>> http://www.vtk.org/mailman/listinfo/vtk-developers
>>
>>
>