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

首先清楚两点：

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

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

 

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

两个类对象m，n

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

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

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

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

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

 

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

 1 #include <iostream>

 2 using namespace std;

 3 

 4 template <typename T>

 5 class dynamicClass

 6 {

 7 public:

 8   dynamicClass(const T&,const T&);

 9   dynamicClass(const dynamicClass<T>&);

10   dynamicClass<T>& operator=(const dynamicClass<T>&);

11   friend ostream& operator<<(ostream &os,const dynamicClass<T> &rhs)

12   {

13     os << rhs.member1 << " " << rhs.member2 << ":" << *rhs.member2;

14     return os;

15   }

16   ~dynamicClass();

17 private:

18   T member1;

19   T *member2;

20 };

21 

22 template <typename>

23 dynamicClass<T>::dynamincClass(const T &m1,const T &m2):member1(m1)

24 {

25   member2 = new T(m2);

26 }

27 

28 template <typename T>

29 dynamicClass<T>::dynamicClass(const dynamiicClass<T> &rhs):member1(rhs.member1)

30 {

31   member2 = new T(*rhs.member2);

32 }

33 

34 template <typename T>

35 dynamicClass<T>& dynamicClass<T>::opeartor=(const dynamicClass<T> &rhs)

36 {

37   member1 = rhs.member1;

38   *member2 = *rhs.member2;

39   return *this;

40 }

41 

42 template <typename T>

43 dynamicClass<T>::~dynamincClass()

44 {

45   delete member2;

46 }