destructor of template class with pointer

Question

I have a question. Consider this template class

template<class T> 
class nodo{
public:
    T data;
};

Let's suppose that I'm not redefining the destructor. If we suppose that T=int, the standard destructor deallocates data. But what happens if T=int* ? Is just the pointer going to be deallocated or the object pointed too? In theory just the pointer.

How can I deallocate the object pointed to? In the end, how can I write the destructor of a template class that has a template parameter that could be a pointer (and so of an explicit deallocation)?

easy fix, make `T` be `unique_ptr` instead. Then the pointed-to object is automatically destroyed — kmdreko, Jun 07 '16 at 20:22
It's no different than had you done `class nodo { public: int* data;}`. — GManNickG, Jun 07 '16 at 20:22

score 3 · Accepted Answer · edited May 23 '17 at 12:22

Your best option is to use std::unique_ptr<int> or std::shared_ptr<int> as the template argument, i.e. use

nodo<std::unique_ptr<int>> n1;

instead of

nodo<int*> n1;

You can try something like:

// Noop deleter
template <typename T> struct deleter
{
   void operator()(T& ptr) {}
};

// deleter that does something
template <typename T> struct deleter<T*>
{
   void operator()(T* ptr) { delete ptr; }
};


template<class T> 
class nodo{
public:
   using deleter_t = deleter<T>;
    T data;

    ~nodo()
    {
       deleter_t()(data);
    }
};

However, then you have to worry about another can of worms. What happens when nodo is copy-constructed or assigned to another nodo object? You need to take care of all the issues that make The Rule of Three and The Rule of Five relevant.

@CodeBott, use `nodo` for nodes of type `int`. Use `nodo>` instead of `node` when the nodes are meant to hold pointers. — R Sahu, Jun 07 '16 at 20:45

score 2 · Answer 2 · answered Jun 07 '16 at 20:29

2

What you need is a partially specialized template for pointer types:

template<typename T> class Test {
  T  val;
public:
  Test(T const &v) : val(v) {}
};

// Specialize for pointers
template<typename T> class Test<T*> {
  T* val;
public:
  Test(T* v) : val(v) {}
  ~Test() { delete  val; }
};

answered Jun 07 '16 at 20:29

Thomas B Preusser

1,139
5
10

At least prohibit copying of the class when T is a pointer. Otherwise you will have UB if class is ever copied. – Revolver_Ocelot Jun 07 '16 at 20:54

destructor of template class with pointer

2 Answers2