项目地址
概观(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)
- 每种容器都有其对应的迭代器
