课堂大纲
这周的课程大致上应该是这三个部分
- C++模板介绍
- 泛型编程
- 容器
概述STL与泛型编程
泛型编程作为一种编程思维和想法，它是一种编程方法，不依赖于具体的语言。
STL中主要由容器，迭代器，算法三个部件构成。
容器用来管理对象的集合，每一种容器都有自己的优缺点，储存的方式等都有所不同，使用时需根据程序的需求考虑不同容器的效率来选择
迭代器为所有容器提供了一组公共接口，并且，每一种容器都提供自己的迭代器
STL中把数据和算法分开，赋予了STL极大的弹性
下图演示了三个部件之间的交互关系
可以看出，迭代器是容器和算法之间的接口，总体说来，STL使容器与算法分离，使其二者不需要相互依赖，而迭代器又将算法和不同的容器stick在一起，从而使需要的算法能够运用到不同的容器上
Templates and Generic Programming
- 泛型技术（Generic Programming）。比如：模板技术，RTTI技术，虚函数技术，要么是试图做到在编译时决议，要么试图做到运行时决议。
- 模板（Templates）是泛型编程的基础
C++模板介绍
C++主要有两种类型的模板
- 类模板(Class template):使用泛型参数的类
- 函数模板(Function template):使用泛型参数的函数
模板实例化：显示和隐式两种方式
类模板实参可以是某一型别或常量(仅限int或enum)
C++类模板的声明注意事项：
- 声明类模板和声明函数模板类似
- 关键字class和typename都可以用，但还是倾向于使用typename
templateclass Stack{......};
template class Stack{......};
3.在类模板内部，T可以像其他型别一样(比如int,char等)定义成员变量和成员函数
void Push(const T const& element);
int Pop(T& element);
int Top(T& element) const;
std::vector m_Members;
泛型编程(Generic programming)
泛型编程作为一种编程思维和想法，它是一种编程方法，不依赖于具体的语言。
- 关联特性(Traits)
Traits可以实现为模板类, 而关联则是针对每个具体型别T的特化.
template< typename T > class Simg{ };
template< > class Simg< char>{
public: typedef int ReturnType ;
};
template< > class Simg< short>{
public: typedef int ReturnType ;
};
template< > class Simg< int>{
public: typedef long ReturnType ;
};
Traits实现: (函数定义)
template< typename T>
typename Simg< T >::ReturnType Sigma ( const T const* Start, const T const* end)
{
Simg< T >::ReturnType type;
type r = ReturnType();
return r ; //这里返回的就是特性的新类型}
- 迭代器(Iterators)：迭代器是指针的泛化（generalization of pointers）
2.1 迭代器本身是一个对象，指向另外一个（可以被迭代的）对象。
2.2 用来迭代一组对象，即如果迭代器指向一组对象中的某个元素，则通过increment以后它就可以指向下一组对象中的一个元素。
迭代器是指针的泛化(generalization of pointers)
- 迭代器本身是一个对象，指向另外一个(可以被迭代的)对象
- 用来迭代一组对象，即如果迭代器指向一组对象中的某个元素，则通过increment以后它就可以指向这组对象的下一个元素
- 在STL中迭代器是容器与算法之间的接口
- 算法通常以迭代器作为输入参数
- 容器只要提供一种方式，可以让迭代器访问容器中的元素即可。
迭代器的基本思想
- 在STL中，迭代器最重要的思想就是分离算法和容器，使之不需要相互依赖
- 迭代器将算法和容器粘合(stick)在一起从而使得一种算法的实现可以运用到多种不同的容器上，如下面的例子所示，find算法接收一对迭代器，分别指向容器的开始和终止位置：
templalte
inline _InIt find(_InIt _First,_InIt _Last,const _Ty& _Val){
//find frist matching _Val
for(;_First != _Last;++_First)
if(*_First == _Val)
break;
return (_First);
}
容器container
总的来说，容器可以分为两类：
- 顺序式容器sequence containers
排列顺序与置入次序一致，例如vector，deque，list - 关联式容器associative containers
sort群集，元素的顺序取决于特定的排序规则，例如set，multiset，map，multimap.
顺序容器
Vector
- Vector是一个能够存放任意型别的动态数组
- Vector的数据结构和操作于数组类似，在内存中的表示是一段地址连续的空间。
- Vector与数组的区别在于，数组大小往往是定义的时候已经指定，而Vector支持动态空间大小调整，随着元素的增加，Vector内部会自动扩充内存空间。
- 为了使用Vector,必须用include指令包含如下文件，并通过std命名空间去访问:
#include
int main(){
std::vector v;
}
创建一个vector,提醒两个比较特殊的：
vector<T> v(v,i); //创建一个容量为n的T型别的vector，并都初始化为i
int a[] = {1,2,3,4,5,6,7,8,9,10};
vecotr<int> v(a,a+10); //用数组创建vector
相关函数:
vector我们平时使用的比较多，push_back()，empty()都是常用的就不说了，注意vector没有push_front()，因为对于vector来说如果要push_front()效率很低所以不提供这个函数。
对于vector的at()和operator[]，at会做边界检查，但效率比operator低。
删除元素的操作：
clear()直接清空
pop_back()弹出尾部
erase()借助迭代器清除（传入迭代器，也就是位置，也可以是一个范围）
iterator erase (iterator position);
iterator erase (iterator first, iterator last);
另外，我们可以用eraze结合remove_if(定义在<algorithm>中)来删除我们指定的元素：
首先，我们需要定义一个删选器：用一个一元对象（unary_function)，其关键在于重载operator()：
struct ContainsString:public unary_function<string,bool>
{
ContainsString(const string& szMatch) :m_szMatch(szMatch) {}
bool operator()(const string& szStringToMatch)const {
return (szStringToMatch.find(m_szMatch) != -1);
}
string m_szMatch;
};
还记的我们上面所说的erase的用法么，第二个用法第一个参数为eraze的起点，我们的erase函数这样写：
v.erase(remove_if(
v.begin(),
v.end(),
ContainsString("bushuang")
),
v.end());
我们看remove_if的用法：
template <class ForwardIterator, class UnaryPredicate>
ForwardIterator remove_if (ForwardIterator first, ForwardIterator last,
UnaryPredicate pred);
第三个参数可以看到就是一个一元条件，而前两个参数为起止迭代器，返回值是迭代器，所以现在就很清楚了，通过remove_if得到一个迭代器位置，然后从该位置把后面的东西都删了。
remove_if属于移除性算法，根据元素值或某一准则，在一个区间内移除某些元素。这些算法并不能改变元素的数量，它们只是以逻辑上的思考，将原本置于后面的“不移除元素”向前移动，覆盖那些被移除元素而已，它们都返回新区间的逻辑终点（也就是最后一个“不移除元素”的下一位置）。
Deque
Deque是一个能够存放任意型别的双向队列，故比vector多了push_front和pop_front两个函数，而我们之前提到过vector因为效率原因不提供这两个函数，所以deque必然与vector有不同的内存管理方法：大块的内存分配。
如果不是要在前面插入，一般我们不会去用Deque，所以也就不多说了，其用法和vector差不多，只是效率上的差别
List
list相较于vector和deque，其优势在于可以很快的随意插入和删除元素，对于插入，删除，替换等操作，效率极高，合并list，也仅仅只需要节点的链接
相关函数:
void remove (const value_type& val);直接删除指定内容的元素
erase与上面差不多，不多说了
具体说一下splice
void splice (iterator position, list& x); //entire list
void splice (iterator position, list& x, iterator i); //single element
void splice (iterator position, list& x, iterator first, iterator last); //element range
简单说明一下参数，第二个函数剪贴单个元素，第三个参数为传入list x的迭代器；
第三个函数后两个参数为传入list x的迭代器范围
用以下代码说明用法：
// splicing lists
#include <iostream>
#include <list>
int main ()
{
std::list<int> mylist1, mylist2;
std::list<int>::iterator it;
// set some initial values:
for (int i=1; i<=4; ++i)
mylist1.push_back(i); // mylist1: 1 2 3 4
for (int i=1; i<=3; ++i)
mylist2.push_back(i*10); // mylist2: 10 20 30
it = mylist1.begin();
++it; // points to 2
mylist1.splice (it, mylist2); // mylist1: 1 10 20 30 2 3 4
// mylist2 (empty)
// "it" still points to 2 (the 5th element)
mylist2.splice (mylist2.begin(),mylist1, it);
// mylist1: 1 10 20 30 3 4
// mylist2: 2
// "it" is now invalid.
it = mylist1.begin();
std::advance(it,3); // "it" points now to 30
mylist1.splice ( mylist1.begin(), mylist1, it, mylist1.end());
// mylist1: 30 3 4 1 10 20
std::cout << "mylist1 contains:";
for (it=mylist1.begin(); it!=mylist1.end(); ++it)
std::cout << ' ' << *it;
std::cout << '\n';
std::cout << "mylist2 contains:";
for (it=mylist2.begin(); it!=mylist2.end(); ++it)
std::cout << ' ' << *it;
std::cout << '\n';
return 0;
}
里面用到的advance函数作用是移动迭代器（第二参数可为负数）
我们在使用splice的时候，注意iterator 的位置，advance函数第二参数不要让迭代器超过范围，否则将导致不可预知的问题。另外，list还有sort()与merge()函数。
