老是记不住的模板

类模板与模板类的区别

类模板是模板的定义，不是一个实实在在的类，定义中用到通用类型参数。

模板类是实实在在的类定义，是类模板的实例化。类定义中参数被实际类型说代替。

类函数同理

只有当用到了实际的模板类或模板函数，编译器才会创建一个实际的模板函数定义

例如：

template < class T > //T为类型形式参数

T max( T a, T b) 
{
　　return a>b?a:b;
}

void main()
{
　　cout << "max(3,5) is" //这里3,5为实际参数
　　　　<< max(3,5) <<endl;
　　cout <<"max('3','5') is"
　　　　<< max('3','5')<<endl;
}

 

运行结果为：

max（3,5） is 5

max（‘3’，‘5’） is 5

当编译器发现用指定数据类型调用函数模板时，才会创建一个模板函数。

上例中，当编译程序发现max（3,5）调用时，它就产生了一个如下的函数定义，生成其程序代码：

这样实际参数是什么类型，返回值也是什么类型。

int max ( int a, int b)

{

　　return a>b?a:b;

}

 

类模板

template<class T> class List
{

　　public :
　　　　list();
　　　　~list();
　　　　void add(T&);
　　　　void Remove(T&);
}

template<class T> List<T>::List()
{
　　pFirst = 0;
}

template < class T >
void List < T >::Add( T& t )
{
　　Node * temp = new Node;
　　temp->pT = &t;
　　　　temp->pNext = pFirst;
　　　　pFirst = temp;
}
void List<T>::Remove(T& t)
{
.......
}

template< class T>
T* List<T>::Find( T& t)
{
.......
}

 

 

 

使用类模板

定义一个list对象

List<float> floatList; 

编译器发现实际参数为float就定义了一个float的list类。

 

 

其他例子：

#include <iostream>

template <typename T>
class Foo
{
public:
    Foo() {}
    ~Foo() {}
    //成员函数有自己的模板参数
    template <typename S>
    void print_s_a(S p)
    {
        std::cout << "S= " << p << std::endl;
        std::cout << "T = " << _a << std::endl;
    } 

    template <typename TT>
    void print_tt_a(TT p);

private:
    T _a;    
};

//注意成员模板函数定义在类外的方法
template <typename T>
template <typename TT>
void Foo<T>::print_tt_a(TT p)
{
    std::cout << "TT = " << p << std::endl;
    std::cout << "T = " << _a << std::endl;
}

int main()
{
    Foo<int> f;
    f.print_s_a("123");

    f.print_tt_a("456");
    return 0;
}