C++模板学习

一、什么是模板？

　　模板就是实现代码重用机制的一种工具，它可以实现类型参数化，即把类型定义为参数，从而实现了真正的代码可重用性。模板可以分为两类，一个是模板函数，一个是模板类。

二、c++中的模板和模板类

　　What's better than having several classes that do the same thing to different datatypes? One class that lets you choose which datatype it acts on.

　　模板提供了这样一种途径来定义类的行为（无需事先了解哪种数据类型将会被用于类的操作处理上），本质上说就是大家所熟知的泛型编程。

the basic syntax for declaring a template class is as follows:

template <class a_type>
class a_class
{
     ......   
};

在定义模板类中的变量时，如下行所示：

a_type a_var;

我们需要将模板类的成员函数定义为模板函数：

template <class a_type>
a_type a_class<a_type>::a_function()
{
     ......   
}

when declaring an instance of a template class, the syntax is as follows:

类模板的实例化对象就叫做特化模板类，模板参数不再使用抽象的类型，而是直接使用具体的类型来实例化该模板类。

a_class<int> an_example_class;

下面给出一个模板样例来作为这一小节的结束

template <class T>
class calc
{
     public:
         T multiply(T x, T y);
         T add(T x, T y);
};

template <class T>
T calc<T>::multiply(T x, T y)
{
    return x*y;
}

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

now， when you instantiate an object of class calc you can choose which datatype the class will handle.

calc<double> a_calc_class;

三、模板函数

　　在上一节中我们已经对模板函数有了一些了解，接下来再较详细介绍一下。模板函数实例化如下，我们在实际应用中可以用任意类型来实例化该模板函数

#include <stdio.h>

template<class T>
T cosnt &max(T const &a, T const &b)
{
     return a < b ? b : a;
}   

int main()
{
    printf("The max value is %d
",max(4,5));    //max<int>
    printf("The max value is %f
",max(4.1,5.1));    //max<float>
    return 0;
}

　　和普通函数重载一样，模板函数也可以实现函数重载的功能，如下所示：

///////////////////////////////////////////////////////////
//  Copyright (c) 2013, ShangHai xxxxx Inc.
//
//    FileName:   overloadTemplateFunc.cpp
//
//    Description:
//
//    Created:    Wed Sep 25 14:41:21 2013
//    Revision:   Revision: 1.0
//    Compiler:   g++
//
///////////////////////////////////////////////////////////
#include <stdio.h>

int const &max(int const &a, int const &b) 
{
    printf("int const &max(int const &a, int const &b) is called.
");
    return a < b ? b : a;
}

template <class T>
T const &max(T const &a, T const &b) 
{
    printf("T const &max(T const &a, T const &b) is called.
");
    return a < b ? b : a;
}

template <class T>
T const &max(T const &a, T const &b, T const &c) 
{
    printf("T const &max(T const &a, T const &b, T const &c) is called.
");
    return max(max(a,b),c);
}

class MyClass
{
    public:
        MyClass(int value):m_value(value)
        {   
        }   
        bool operator<(const MyClass &other) const
        {   
            printf("operator < is called.
");
            return m_value < other.m_value;
        }
        int getValue() const
        {
            return m_value;
        }

    private:
        int m_value;
};

int main()
{
    printf("--------------------------------
");
    max(5,10,15);
    printf("--------------------------------
");
    max(5,10);
    max<>(5,10);
    max('a','b');
    max('a',10);
    printf("--------------------------------
");
    MyClass class1(10),class2(100);
    max(class1,class2);
    printf("--------------------------------
");

    getchar();
    return 0;
}

[yangtze@contex201 ~]$ ./overloadTemplateFunc
--------------------------------
T const &max(T const &a, T const &b, T const &c) is called.
int const &max(int const &a, int const &b) is called.
int const &max(int const &a, int const &b) is called.
--------------------------------
int const &max(int const &a, int const &b) is called.
T const &max(T const &a, T const &b) is called.
T const &max(T const &a, T const &b) is called.
int const &max(int const &a, int const &b) is called.
--------------------------------
T const &max(T const &a, T const &b) is called.
operator < is called.
--------------------------------

　　结合运行结果分析，可以总结以下几点：

1）编译器在进行函数重载的推演时，首选非模板类型函数；

max（5,10）的运行结果是：

　　int const &max(int const &a, int const &b) is called.

max（5,10,15）的运行结果是：

　　T const &max(T const &a, T const &b, T const &c) is called.
　　int const &max(int const &a, int const &b) is called.
　　int const &max(int const &a, int const &b) is called.

2）非模板和模板可以同名，在调用时可以一起进行函数重载的推演（显而易见）；

3）通过max<>方式通知编译器，在推演时只考虑函数模板；

max<>（5，10）的运行结果是：

　　T const &max(T const &a, T const &b) is called.

4）模板函数实例化过程中，并不会自动完成任何形式的类型转换，而普通函数max通过类型自动转换（（int）'a',10）可以覆盖该调用，使得编译器选择了普通函数。

max（'a'，10）的运行结果是：

　　int const &max(int const &a, int const &b) is called.

四、模板类特化

　　//TODO