自定义使用动态内存的类模板

首先清楚两点：

当类有动态分配内存的对象时，运行系统只销毁对象而不销毁内存（导致内存泄漏）---自定义析构函数

对于动态分配内存的类，初始化（复制）和赋值的默认版本不能正确管理内存 ---自定义复制函数和赋值操作符

考虑一个类有两个成员，几个静态分配内存的成员a，一个动态分配内存的指针成员p，p指向一个动态分配的内存，存储值b

两个类对象m，n

m=n 默认的操作是 m.a=n.a   m.p=n.p

但是由于p是一个指针，这样原先m.p的指针指向的内存将没有指针指向，同时内存依然存在，导致内存泄漏

复制也会出现类似的问题。

一般含有动态分配内存的对象的类，都有指针成员，但是复制或赋值时，默认的版本会复制指针本身，而通常不希望这样，而是复制指针指向的对象

这就需要自定义复制函数和复制操作符

示例代码并复习自定义类模板的内容：

#include <iostream>
using namespace std;

template <typename T>
class dynamicClass
{
public:
  dynamicClass(const T&,const T&);
  dynamicClass(const dynamicClass<T>&);
  dynamicClass<T>& operator=(const dynamicClass<T>&);
  friend ostream& operator<<(ostream &os,const dynamicClass<T> &rhs)
  {
    os << rhs.member1 << " " << rhs.member2 << ":" << *rhs.member2;
    return os;
  }
  ~dynamicClass();
private:
  T member1;
  T *member2;
};

template <typename>
dynamicClass<T>::dynamincClass(const T &m1,const T &m2):member1(m1)
{
  member2 = new T(m2);
}

template <typename T>
dynamicClass<T>::dynamicClass(const dynamiicClass<T> &rhs):member1(rhs.member1)
{
  member2 = new T(*rhs.member2);
}

template <typename T>
dynamicClass<T>& dynamicClass<T>::opeartor=(const dynamicClass<T> &rhs)
{
  member1 = rhs.member1;
  *member2 = *rhs.member2;
  return *this;
}

template <typename T>
dynamicClass<T>::~dynamincClass()
{
  delete member2;
}