项目地址

概观(Overview)

泛型编程是一种编程方式，这种方法将型别(type)以一种<code>to-be-specified-later</code>的方式给出，等到需要调用的时候，再以参数方式，通过具体的、特定的型别实例化(instantiate)一个具体的方法或对象
泛型编程作为一种编程的想法或思维，不依赖于具体的语言
大多数面向对象的语言(OO languages)都支持泛型编程，比如：C++,C#,Java,Ada,...
C++里面的泛型是通过模板以及相关性质表现的

关联特性(Traits)

特性(1)

什么是traits以及为什么使用traits?
假设给定一个数组，计算数组中所有元素的和：
A[0] A[1] ... A[n] sum(A)
我们可以很直接的写出如下的计算函数：


template <typename T> inline T Sigma(const T const* start, const T const* end) {
    T total = T();  //suppose T() actually creates a zero value
    while (start != end) {
        total += *start++;
    }

    return total;
}

特性(2)

什么是traits以及为什么使用traits?(续)
当我们使用char型别调用模板函数时，问题来了：


char szNames[] = "abd";
std::size_t nLength = strlen(szNames);
char* p = szNames;
char* q = szNames + nLength;
printf("Sigma(szNames) = %d\n", Sigma(p,q));

traits2

调用Sigma(szNames)的结果是38(=0x26)!而并非期盼的值(97+98+99=294)
原因是显而易见的：char型别无法存下294这个值！
如果要得到正确的结果，我们不得不强制使用int型别：
int s = Sigma<int>(p,q);
但是这种不必要的转换是完全可以避免的！

特性(3)

什么是traits以及为什么使用traits?(续)
解决的方法是：为每个Sigma函数的参数型别T创建一种关联(association)，关联的型别就是用来存储Sigma结果的型别
这种关联可以看作是型别T的一种特性(characteristic of the type T)，因此Sigma函数返回值的型别叫做T的trait
T与其trait的关系推演如下：
T -> association -> characteristic of T -> another type -> trait!
Traits可以实现为模板类，而关联(association)则是针对每个具体型别T的特化。在这个例子里我们将traits命名为SigmaTraits，叫做(traits template)

特性(4)

Traits实现


template <typename T> class SigmaTraits{};
template <> class SigmaTraits<char> {
    public: typedef int ReturnType;
};

template <> class SigmaTraits<short> {
    public: typedef int ReturnType;
};

template <> class SigmaTraits<int> {
    public: typedef long ReturnType;
};

template <> class SigmaTraits<unsigned int> {
    public: typedef unsigned long ReturnType;
};

template <> class SigmaTraits<float> {
    public: typedef double ReturnType;
};

traits4

特性(5)

Traits实现(续)
模板类SigmaTraits叫做traits template，它含有其参数型别T的一个特性(trait)，即ReturnType
现在Sigma函数可以改写如下：


template <typename T>
inline typename SigmaTraits<T>::ReturnType Sigma(const T const* start, const T const* end)
{
    typedef typename SigmaTraits<T>::ReturnType ReturnType;
    ReturnType s = ReturnType();
    while (start != end)
        s += *start++;

    return s;
}

特性(6)

Traits实现
现在如果我们以char为型别调用Sigma将得到预想中的结果：


char szNames[] = "abc";
std::size_t nLength = strlen(szNames);
char* p = szNames;
char* q = szNames + nLength;
printf("Sigma(szNames) = %d\n", Sigma(p,q));

虽然传入参数T的型别是char，但是返回的型别却是int，原因就在于template <> class SigmaTraits<char>的返回值变成了int(通过typedef int ReturnType)

迭代器(1)

什么是迭代器？
迭代器是指针的泛化(generalization of pointers)
迭代器本身是一个对象，指向另外一个(可以被迭代的)对象
用来迭代一组对象，即如果迭代器指向一组对象中的某个元素，则通过increment以后它就可以指向这组对象中的下一个元素
在STL中迭代器是容器与算法之间的接口
算法通常以迭代器作为输入参数
容器只要提供一种方式，可以让迭代器访问容器中的元素即可

迭代器(2)

迭代器的基本思想
在STL中，迭代器最重要的思想就是分离算法和容器，使之不需要互相依赖
迭代器将算法和容器粘合(stick)在一起从而使得一种算法的实现可以运用到多种不同的容器上，如下面的例子所示，find算法接受一对迭代器，分别指向容器的开始位置和最终位置：


template<class _Init, class _Ty>
inline _Init find(_Init _First, _Init _Last, const _Ty& _Val) {
    //find first matching _Val
    for (; _First != _Last; ++_First)
        if (*_First == _Val)
            break;
    return (_First);
}

迭代器(3)

迭代器的基本思想(续)
find算法对于不同的容器，比如vector,list,deque均适用：


std::vector<int> v(...);
std::list<int> l(...);
std::deque<int> d(...);

std::vector<int>::iterator itv = std::find(v.begin(), v.end(), elementToFind)
std::list<int>::iterator itl = std::find(l.begin(), l.end(), elementToFind)
std::deque<int>::iterator itd = std::find(d.begin(), d.end(), elementToFind)