用类模板实现容器存储自定义数据类型（类似于STL里面的vector）

上一节里面已经提到了，用类模板存储自定义的数据类型，如Teacher类型时，需要重载Teacher类的拷贝构造函数，“=”操作符，"<<"操作符，特别要注意深拷贝和浅拷贝的问题。

例如：

//1.myvector.h文件
#ifndef MYVECTOR_H
#define MYVECTOR_H

#include <iostream>
using namespace std;

template<typename T>
class Myvector
{
    friend ostream& operator<<<T>(ostream& out,Myvector<T>& obj);
public:
    Myvector(int size);//构造函数
    Myvector(Myvector<T>&);//拷贝构造函数
    ~Myvector();//析构函数

public:
    Myvector<T>& operator=(const Myvector<T>& obj);
    T& operator[](int index);
    int getlen(){return my_len;}

private:
    T*  my_space;//模板数组的首地址
    int my_len;//模板数组的长度，等于最大索引数+1
};

#endif


//2.myvector.cpp文件
#include <iostream>
#include "myvector.h"


using namespace std;

//构造函数
template<typename T>
Myvector<T>::Myvector(int size)
{
    my_len=size;
    my_space=new T[my_len];
    if(my_space==NULL)
    {
        cout<<"调用构造函数 分配内存失败！"<<endl;
        return;
    }
}

//拷贝构造函数，深拷贝。拷贝构造函数也是构造函数，一开始my_len,my_space的值都是没有的（随机数），不存在释放什么的，全是要靠自己复制才会有
template <typename T>
Myvector<T>::Myvector(Myvector<T>& obj)
{
    my_len=obj.my_len;
    my_space=new T[my_len];
    
    for(int i=0;i<my_len;i++)
    {
        my_space[i]=obj.my_space[i];
    }
}

//析构函数
template<typename T>
Myvector<T>::~Myvector()
{
    cout<<"调用模板类的析构函数"<<endl;
    if(my_space!=NULL)
    {
        delete [] my_space;
        my_space=NULL;
        my_len=0;
    }
}

//重载"[]"操作符
template<typename T>
T& Myvector<T>::operator[](int index)
{
    return this->my_space[index];
}


//重载"="操作符
template<typename T>
Myvector<T>& Myvector<T>::operator=(const Myvector<T>& obj)
{
    if(my_space!=NULL)
    {
        my_len=0;
        delete [] my_space;
        my_space = NULL;
    }

    my_len=obj.my_len;
    for(int i=0;i<my_len;i++)
    {
        my_space[i]=obj.my_space[i];
    }

    return *this;
}


//重载"<<"运算符
template<typename T>
ostream& operator<<(ostream& out,Myvector<T>& obj)
{
    for(int i=0;i<obj.my_len;i++)
    {
        out<<obj.my_space[i]<<" ";
    }
    return out;
}


//3.main.cpp文件
#include <iostream>
#include"myvector.cpp"
#include"myteacher.h"
#include<string>

using namespace std;

class Teacher
{
    friend ostream& operator<<(ostream& out,const Teacher& t);
public:
    //构造函数，不带参
    Teacher()
    {
        age=0;
        name=NULL;
    }

    //构造函数，带参
    Teacher(int a,char* n)
    {
        age=a;
        int name_len=strlen(n);
        name=new char[name_len+1];
        strcpy(name,n);
    }

    //拷贝构造函数
    Teacher(const Teacher& t)
    {
        age=t.age;
        int name_len=strlen(t.name);
        name=new char[name_len+1];
        strcpy(name,t.name);
    }

    //析构函数
    ~Teacher()
    {
        cout<<"调用Teacher类的析构函数"<<endl;
        if(name!=NULL)
        {
            age=0;
            delete [] name;
            name=NULL;
        }
    }

    //重载"="操作符
    Teacher& operator=(Teacher& t)
    {
        if(name!=NULL)
        {
            delete [] name;
            name=NULL;
            age=0;
        }
    
        int name_len=strlen(t.name);
        name=new char[name_len+1];
        strcpy(name,t.name);
        age=t.age;

        return *this;
    }

    void printT()
    {
        cout<<age<<" "<<name<<endl;
    }


private:
    int age;
    char* name;
};

ostream& operator<<(ostream& out,const Teacher& t)
{
    out<<t.age<<" "<<t.name;
    return out;
}


int main()
{
    Teacher t1(26,"Wu"),t2(33,"Li");
    
    Myvector<Teacher> v(3);

    v[0]=t1;
    v[1]=t2;

    cout<<v[0]<<endl;
    cout<<v[1]<<endl;


    
    return 0;
}

上述代码的执行结果是：

26 Wu

33 Li

调用模板类的析构函数

调用Teacher类的析构函数

调用Teacher类的析构函数

调用Teacher类的析构函数

调用Teacher类的析构函数

调用Teacher类的析构函数

之所以会5次调用Teacher类的析构函数，是因为定义了1个myvector v(3)，即v是包含3个元素的数组，定义了2个Teacher类的对象t1和t2。

然后把v[0]=t1,v[1]=t2，则v[2]是空的。执行析构函数的时候，要析构v里面的元素3次，即3次调用Teacher类的析构函数；调用Teacher类对象的析构函数2次，即t1和t2各析构一次，总共析构了2+3=5次。