模板

template关键字

泛型编程

//template<class T>

//template<typename T>

//template<typename T,typename T1>

//函数模板
//编译器用模板实例化生成对应的Swap函数
template<class T>  
    void Swap(T&i,T&j)
{
    T tmp=i;
    i=j;
    j=tmp;
}
      
  int main()
  {
      int i=0,j=1;
      Swap(i,j);
      float x=1.1,y=2.2;
      Swap(x,y);
      return 0;
  }

类模板

//类模板的实例化
template<class T>
class Stack
{
    public:
    Stack(size_t capacity=4)
    {
        _arr=new T[capacity];
        _size=0;
        _capacity=capacity;
    }
    void push(const T &data)
    {
        _arr[_size]=data;
        _size++;z
    }
  private:
    T* _arr;
    int _size;
    int _capacity;
};
int main()
{
    Stack<int> st1;
    Stack<double> st2;
    return 0  ;
}

   T add(const T&x,const T&y)
{
    return x+y;
}

template<class T>
    T add(const T&x,const T&y)
{
    return x+y;
}

//两个函数可以同时存在，编译器优先使用普通函数
//想要直接使用模板，需要显示实例化
add<int>(1,2);
int main()
{
    add(1,2);
    add(1.1,2);
    //会引起T的异常
    //解决方案一，强转
    add((int)1.1,2);
    add(1.1,(double)2);
    //二，显示实例化
    add<int>(1.1,2);
    add<double>(1.1,2);
    return 0;

tempnam<class T>
class Date
{
  public:
    Date()
    {}
    ~Date()
    {
        ;
    }
  private:
    int _year;
    int _day;
    int _month;
};
//声明与定义分离时指定类域要带模板参数
//由于模板参数的使用范围在类里，所以还要再声明一次
//但是不能分离在两个文件
tempname<class T>
Date<T>::~Date()
{
}

int main()
{
    
    return 0;
}