模板 Templates
语法格式
template<typename/class 类型参数表> //一般不用class
返回类型 函数模板名(函数参数列表)
{
函数模板定义体
}
函数模板 应用条件 1.函数名相同 2.函数的参数个数相同 3.函数的参数类型不同4.函数体相同

#include<cstring>
#include <iostream>
using namespace std;

template<typename T>
class MyVector{
public:
    MyVector(int size=0);//构造
    MyVector(const MyVector&obj);//拷贝
    ~MyVector();//析构
    T& operator[](int index);//重新定义[]
    MyVector& operator=(const MyVector&obj);//重新定义=
    template<typename T1>
    friend ostream& operator <<(ostream &out,MyVector<T1> &obj);//重新定义<<
    template<typename T1>
    friend istream& operator >>(istream &in,MyVector<T1> &obj);//重新定义>>
    static int a;//放在私有用set get出来  //两个不同类型的类模板不共用一个静态变量
private:
    T*m_space;
    int m_len;

};
template<typename T>//静态变量
int MyVector<T>::a=10;

template<typename T>//每段都要加
MyVector<T>::MyVector(int size)//作用域后都要加<T>
{
   m_len=size;
   m_space=new T[m_len];
   memset(m_space,0,sizeof(T)*m_len);
}
template<typename T>
MyVector<T>::MyVector(const MyVector&obj)
{
    m_len=obj.m_len;
    m_space=new T[m_len];
    for(int i=0;i<m_len;i++)
    {
        m_space[i]=obj.m_space[i];
    }
}
template<typename T>
MyVector<T>::~MyVector()
{
    if(NULL!=m_space)
    {
        delete []m_space;
        m_space=NULL;
        m_len=0;
    }
}
template<typename T>
T& MyVector<T>::operator[](int index)
{
    return m_space[index];
}
template<typename T>
MyVector<T>& MyVector<T>::operator=(const MyVector<T>&obj)
{
    delete[]m_space;
    m_len=obj.m_len;
    m_space=new T[m_len];
    for(int i=0;i<m_len;i++)
    {
        m_space[i]=obj.m_space[i];
    }
    return *this;
}
template<typename T1>
ostream& operator <<(ostream &out,MyVector<T1> &obj)
{
    for(int i=0;i<obj.m_len;i++)
    {
        out<<obj.m_space[i]<<endl;
    }
    return out;
}
template<typename T1>
istream& operator >>(istream &in,MyVector<T1>&obj)
{
    for(int i=0;i<obj.m_len;i++)
    {
        in>>obj.m_space[i];
    }
    return in;
}

#include <iostream>
using namespace std;

class Teacher
{
public:
    Teacher();
    Teacher(const char*name,int age);
    Teacher(const Teacher&obj);
    ~Teacher();
    Teacher& operator =(const Teacher&obj);
    friend ostream&operator <<(ostream&out,const Teacher&obj);
private:
    char *m_name;
    int m_age;

};
Teacher::Teacher()
{
    m_age=0;
    m_name=new char[1];
    strcpy(m_name,"");
}
Teacher::Teacher(const char*name,int age)
{
    m_age=age;
    m_name=new char[strlen(name)+1];
    strcpy(m_name,name);
}
Teacher::Teacher(const Teacher&obj){
    m_age=obj.m_age;
    m_name=new char[strlen(obj.m_name)+1];
    strcpy(m_name,obj.m_name);
}
Teacher::~Teacher()
{
    if(NULL!=m_name)
    {
        delete[]m_name;
        m_name=NULL;
        m_age=0;
    }
}
Teacher& Teacher::operator =(const Teacher&obj)
{
    if(m_name!=NULL)
    {
        delete[]m_name;
        m_name=NULL;
    }
    m_age=obj.m_age;
    m_name=new char[strlen(obj.m_name)+1];
    strcpy(m_name,obj.m_name);
    return *this;
}
ostream&operator <<(ostream&out,const Teacher&obj)
{
    out<<obj.m_name<<" "<<obj.m_age<<endl;
    return out;
}

#include"myvector.h"
#include"teacher.h"
int main()
{

    MyVector<int> a(10);//T=int
    for(int i=0;i<10;i++)
    {
        a[i]=i+100;
    }
//    cin>>a;
    MyVector<int> b(a);
    cout<<b[2]<<b[1]<<endl;
    MyVector<int> c;
    c=a;
    cout<<c[2]<<c[1]<<endl;
    cout<<a<<endl;

    MyVector<Teacher> tech(3);//T=class
    Teacher t1;
    Teacher t2("wangnan",25);
    Teacher t3(t2);
    tech[0]=t1;
    tech[1]=t2;
    tech[2]=t3;
    cout<<tech<<endl;


    MyVector<Teacher*> tech1(3);//T=class*
    tech1[0]=&t1;
    tech1[1]=&t2;
    tech1[2]=&t3;
    cout<<*tech1[0]<<endl;
    cout<<*tech1[1]<<endl;
    cout<<*tech1[2]<<endl;
    return 0;
}

模板定义很特殊。由 template<…> 处理的任何东西都意味着编译器在当时不为它分配存储空间，它一直处于等待状态直到被一个模板实例告知。在编译器和连接器的某一处，有一机制能去掉指定模板的多重定义。所以为了容易使用，几乎总是在头文件中放置全部的模板声明和定义,文件后缀为.hpp