C++泛型 函数模板 template＜typename T＞

泛型：

1、函数模板：
函数体一致， 只是数据不确定

int add(int a,int b) 
  {
       return a+b; 
  }
 //重载函数 
double add(double a,double b) 
 {
      return a+b;
 }
//函数模板
template<typename T>
T add(T a,T b)
{
        return a+b;
}
int main()
{
        //由实参来决定T类型
        cout<<add(1,2)<<endl;
        cout<<add(1.2,2.2)<<endl;
}

PS:实参来确定T类型
PS: template只能修饰一个函数

2、类模板：
类成员与方法一致，只是数据类型不同
定义泛型：

 tempalte<typename T> 
 class stack
  {
	T ...
  };

说明：stack不是一个泛型类型。
PS:在泛型类中，可以包含有泛型，也可包含有确定类型
PS:在泛型类中，不能调用函数实参来确定T，也就是说在实例化时必须来指明。
PS: stack<类型> 对象;
在用到泛型类时，必须声明类型，也就是说在类外实现方法时凡是用到泛型类时必须声明类型。< T >

template<typename T>
	void stack<T>::Push(T d)
	{	
	      if(this->IsFull())
		            return;
	     this->buf[++this->top]=d;
	}

eg:模板栈

template<typename T>
class stack
{
public:
        //类内
        stack():top(-1){}
        void Push(T/*类型*/);
        void Pop();
        T/*类型*/ GetTop();
        bool IsEmpty()
        {
                if(top==-1)
                        return true;
                else
                        return false;
        }
        bool IsFull();
private:
        T/*类型*/ buf[MAXSIZE];//数据域:只能存放int   符号:char  double数据
        int top;//栈顶
};
//类外
template<typename T>
void stack<T>::Push(T d)
{
        if(this->IsFull())
                return;
        this->buf[++this->top]=d;
}
template<typename T>
void stack<T>::Pop()
{
        if(this->IsEmpty())
                return;
        this->top--;
}
template<typename T>
T stack<T>::GetTop()
{
        return this->buf[this->top];
}
template<typename T>
bool stack<T>::IsFull()
{
        if(top==MAXSIZE-1)
                return true;
        else
                return false;
}

int main()
{
//实例化：泛型对象必须在实例化时就指定
        stack<float> s;
        s.Push(1.1);
        s.Push(2.1);
        s.Push(3.1);
        while(!s.IsEmpty())
        {
                cout<<s.GetTop()<<endl;
                s.Pop();
        }

}