Question

我有一个问题。考虑这个模板类

seq1(i) = (seq0(i)*7)%27

seq0    0   1   2   3   4   5   6   7   8   9   10  11  12  13  14  15  16  17  18  19  20  21  22  23  24  25  26  27

seq1    0   7   14  21  1   8   15  22  2   9   16  23  3   10  17  24  4   11  18  25  5   12  19  26  6   13  20  27

seq2    0   22  17  12  7   2   24  19  14  9   4   26  21  16  11  6   1   23  18  13  8   3   25  20  15  10  5   27

我们假设我没有重新定义析构函数。如果我们假设T = int，则标准析构函数释放数据。但是如果T = int *会发生什么？只是指针将被释放或对象指向吗？理论上只是指针。

如何解除分配指向的对象？最后，我如何编写模板类的析构函数，该模板类具有可以作为指针的模板参数（以及显式解除分配）？

Answer 1

您最好的选择是使用std::unique_ptr<int>或std::shared_ptr<int>作为模板参数，即使用

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

而不是

nodo<int*> n1;

您可以尝试以下内容：

// 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);
    }
};

然而，你必须担心另一种蠕虫病毒。 nodo复制构造或分配给另一个nodo对象时会发生什么？您需要处理使The Rule of Three和The Rule of Five相关的所有问题。

Answer 2

您需要的是指针类型的部分专用模板：

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; }
};

带指针的模板类的析构函数

2 个答案: