引言
Program into Your Language, Not in It——《代码大全》。如何深入一门语言去编程？我认为有三步：熟悉它；知道它的局限性；扩展它。如何熟悉？不必说，自然是看书看资料，多用多写。如何知晓其局限性？这步我们只能通过对比了，任何事物都有其自身的局限性，没有任何东西是完美的（除了上帝哈
）。在这里，我用C#与C++做对比，尝试勾勒出C#与C++一些观念上的不同。如何扩展？这点我正在尝试
。
C++的STL
STL包含六大组件：容器(Containers)、迭代器（Iterators）、算法（Algorithms）、仿函数（functors）、配接器（Adapters）、配置器（Allocators）。容器通过配置器取得数据存储空间，算法通过迭代器来存取容器的内容，仿函数协助算法完成不同的操作策略，配接器用来修饰或套接仿函数。这一整套配合，可以使我们完全掌控数据在存储器上的增删查改。（在这里我很想画一张图出来，但是我找了很久，实在找不到好的工具，有没有哪位同学能分享一些好的画示意图之类的工具呢？）
容器
STL中，最常用的容器要算vector、list、map、set这四种了。C#中，对应的容器分别是:List、LinkedList、Dictionary、HashSet。单看容器，其实它只是抽象出了一些逻辑结构，根据不同的逻辑需要，在存储器上反应出不同的物理存储结构。这点C++和C#的抽象没有什么不同，当然，其实现上，很不相同。这点通过代码的书写，就可以略窥一斑。
C++代码如下：
#include <iostream>
#include <vector>
#include <list>
#include <map>
#include <set>
#include <algorithm>
using namespace std;
int main()
{
vector<int> vec;
list<int> lst;
map<int,int> mp;
set<int> st;
for (int i = 0; i < 10; ++i)
{
vec.push_back(i);
lst.push_back(i);
mp.insert(make_pair(i, i));
st.insert(i);
}
cout << "vector: " << endl;
vector<int>::const_iterator iterVec(vec.begin());
while (iterVec != vec.end())
{
cout << *iterVec << endl;
++iterVec;
}
cout << "\nlist: " << endl;
list<int>::const_iterator iterLst(lst.begin());
while (iterLst != lst.end())
{
cout << *iterLst << endl;
++iterLst;
}
cout << "\nmap: " << endl;
map<int, int>::const_iterator iterMap(mp.begin());
while (iterMap != mp.end())
{
cout << "Key = " << iterMap->first
<< "Value = " << iterMap->second
<< endl;
++iterMap;
}
cout << "\nset: " << endl;
set<int>::const_iterator iterSet(st.begin());
while (iterSet != st.end())
{
cout << *iterSet << endl;
++iterSet;
}
}
C#代码如下：
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Collections;
using System.Net.Sockets;
using System.Net;
namespace ConsoleApplication1
{
class Program
{
static void Main(string[] args)
{
List<String> list = new List<String>();
LinkedList<String> linkedList = new LinkedList<String>();
Dictionary<Int32, String> dic = new Dictionary<Int32, String>();
HashSet<String> set = new HashSet<String>();
for (int i = 0; i < 10; ++i )
{
list.Add(i.ToString());
linkedList.AddLast(i.ToString());
dic.Add(i, i.ToString());
set.Add(i.ToString());
}
Console.WriteLine("List: ");
foreach (var item in list)
{
Console.WriteLine(item);
}
Console.WriteLine("\nLinkedList: ");
foreach (var item in linkedList)
{
Console.WriteLine(item);
}
Console.WriteLine("\nDictionary: ");
foreach (var item in dic)
{
Console.WriteLine("Key = {0}, Value = {1}", item.Key, item.Value);
}
Console.WriteLine("\nHashSet: ");
foreach (var item in set)
{
Console.WriteLine(item);
}
}
}
}
C++并没有内置的foreach语句（貌似新的标准中有？），所以它通过迭代器来帮助它来完成迭代。而C#就非常方便了，在语法级别完成了这个功能。从写法上我们可以看到，c++的迭代器看上去是一个指针，是一个可以做自增操作的指针。c#迭代出的每个item则是当前存放的数据。
迭代器
STL中的迭代器有五种：输入迭代器（Input Iterator）、输出迭代器（Output Iterator）、前向迭代器（Forward Iterator）、双向迭代器（Bidirectional Iterator）、随机存取迭代器（Random Access Iterator）。C#中，没有相对应的迭代器概念。毕竟迭代器就是一个智能指针，而C#却不支持指针（unsafe另算哈）。
输入迭代器，只能一次一个向前读取元素，并且只能读取该元素一次。如果我们复制一份输入迭代器，副本输入迭代器和原来的输入迭代器分别向前读取一个元素，那么他们可能会遍历到不同的值。以istream_iterator为列，代码如下：
#include <iostream>
#include <vector>
#include <list>
#include <map>
#include <set>
#include <algorithm>
#include <iterator>
#include <string>
using namespace std;
int main()
{
//按Ctrl+Z结束输入，或者按Ctrl+C取消输入
istream_iterator<string> iterBegin(cin);
istream_iterator<string> iterEnd;
while (iterBegin != iterEnd)
{
cout << *iterBegin << endl;
++iterBegin;
}
}
输出迭代器，与输入迭代器相反，它的作用是将元素值一个个写入，所以只能作为左值。以ostream_iterator为列，代码如下：
#include <iostream>
#include <vector>
#include <list>
#include <map>
#include <set>
#include <algorithm>
#include <iterator>
#include <string>
using namespace std;
int main()
{
ostream_iterator<int> iter(cout, "\n");
vector<int> vec ;
for (int i = 0; i < 10; ++i)
{
*iter = i;
}
}
前向迭代器，是输入、输入迭代器的结合，但是却没能用有输入、输入迭代器的全部功能，真心觉得这个迭代器很尴尬。前向迭代器提取值的时候，要确保它是有效的迭代器（比如到了序列尾端），而输出迭代器却不用（输出迭代器不提供比较操作，无需检查是否达到尾端）。我没见过比较有代表性的前向迭代器，所以给不出代码示例（囧…）。
双向迭代器，在前向迭代器的基础上增加了回头遍历的能力。写法上来说，就是提供了自减操作。最合适的列子非链表的迭代器莫属了。如下：
#include <map>
#include <set>
#include <algorithm>
#include <iterator>
#include <string>
using namespace std;
int main()
{
list<int> lst;
for (int i = 0; i < 10; ++i)
{
lst.push_back(i);
}
list<int>::const_iterator iter(lst.begin());
while (iter != lst.end())
{
cout << *iter << " ";
++iter;
}
cout << endl;
while (iter != lst.begin())
{
--iter;
cout << *iter << " ";
}
}
随机迭代器，在双向迭代器的基础上增加了随机存取能力。写法上来说，就是提供了加减法操作，还提供了大小比较操作(除了这个迭代器，其他都没有大小比较，所以一般判断迭代器是否结尾，是用 == 或者 != 来判断)。最合适的列子就是vector的迭代器了。如下：
vector<int> vec;
for (int i = 0; i < 10; ++i)
{
vec.push_back(i);
}
vector<int>::const_iterator iter(vec.begin());
cout << *(iter + 4) << endl;
至此，我们对C++迭代器有些基本的了解了。现在让我们探索一下这背后到底是怎么实现的。我们知道C++的STL是依靠模板(Template)来实现的，用C#的词来描述就是泛型(Generic)。一个迭代器，其实是一个类型，一个遵循了一系列潜规则的类型。按照被潜的程度，分成两种：自娱自乐，狼狈为奸。如果只是想自娱自乐的话，那么很简单，只要像下面这样既可：
#include <iostream>
#include <vector>
#include <list>
#include <map>
#include <set>
#include <algorithm>
#include <iterator>
#include <string>
using namespace std;
template<typename Item>
struct ListIter;
template<typename T>
struct ListItem;
//作为存放元素的容器
template <typename T>
struct ListContainer
{
ListContainer() : _front(nullptr)
, _end(nullptr)
, _size(0)
{
}
void insert_front(T value)
{
ListItem<T>* newItem = new ListItem<T>(value, _front);
if (_front == nullptr)
{
_end = newItem;
}
_front = newItem;
}
void insert_end(T value)
{
ListItem<T>* newItem = new ListItem<T>(value, nullptr);
if (_end == nullptr)
{
_front = newItem;
_end = newItem;
}
else
{
_end->setNext(newItem);
_end = newItem;
}
}
void display(std::ostream &os = std::cout) const
{
ListItem<T>* tmp = _front;
while (tmp != nullptr)
{
os << tmp->value() << " ";
tmp = tmp->next();
}
os << std::endl;
}
ListItem<T>* front() const
{
return _front;
}
private:
ListItem<T>* _end;
ListItem<T>* _front;
long _size;
};
//每个元素
template<typename T>
struct ListItem
{
ListItem(T val, ListItem<T>* next) : _value(val)
, _next(next)
{
}
T value() const
{
return _value;
}
ListItem* next() const
{
return _next;
}
void setNext(ListItem<T>* next)
{
_next = next;
}
private:
T _value;
ListItem<T>* _next;
};
//迭代器
template<typename Item>
struct ListIter
{
Item* ptr;
ListIter(Item* p = 0) : ptr(p)
{}
Item& operator*() const { return *ptr; }
Item* operator->() const { return ptr; }
ListIter& operator++()
{
ptr = ptr->next();
return *this;
}
ListIter operator++(int)
{
ListIter tmp =*this;
++(*this);
return tmp;
}
bool operator==(const ListIter& i) const
{
return ptr == i.ptr;
}
bool operator!=(const ListIter& i) const
{
return ptr != i.ptr;
}
};
int main()
{
ListContainer<int> myList;
for (int i = 0; i < 10; ++i)
{
myList.insert_front(i);
myList.insert_end(i + 10);
}
myList.display();
ListIter<ListItem<int> > begin(myList.front());
ListIter<ListItem<int> > end;
while (begin != end)
{
cout << begin->value() << endl;
++begin;
}
}
上述代码中，我们完全依赖自己的双手，通过重载*、->、 ++、==、!=等操作符，实现了自己的行为上类似迭代器的迭代器。但是我们仅能自娱自乐而已，不能融入STL的大家庭。我们无法复用STL原有的轮子，也无法将我们的轮子完美的放进STL（只需重载一下全局的!=操作符，可以使用STL的find）。我们为了实现这个迭代器，将容器的元素类型（ListItem）暴露了，而且还暴露了ListItem的内部实现细节（重载++操作符，用到了ptr->next()）,明显不科学啊！所以一般迭代器都是相应的容器的设计者实现的，内嵌在容器中。
如果想让我们的迭代器能融入到STL中，那么，我们就必须为我们的迭代器实现五个“接口”,一个表示迭代器的类型iterator_category，一个表示值类型value_type，一个表示两个迭代器之间的距离类型difference_type，一个表示迭代器的指针pointer，一个表示迭代器的解引用reference。这五个“接口”,就是STL关于迭代器的潜规则。比如一个定义良好的iterator_category可以帮助我们的迭代器在使用distance(),advance()之类的函数时，有更高的效率。为了帮助我们定义自己的迭代器，STL有一个结构，只要我们继承即可，在VS中输入iterator然后转到定义，即可看到下图：
下面让我们来定义一个可以与STL“狼狈为奸”的迭代器。
#include <iostream>
#include <vector>
using namespace std;
template <typename T, typename container = ostream>
struct Our_OutputIterator : public iterator<output_iterator_tag,
T,
ptrdiff_t,
T*,
T&>
{
Our_OutputIterator(container& os) : _os(&os)
{
}
Our_OutputIterator<T, container>& operator*()
{
return *this;
}
Our_OutputIterator<T, container>& operator=(const T& _Val)
{
*_os << _Val << " " ;
return *this;
}
Our_OutputIterator<T, container>& operator++()
{
return *this;
}
Our_OutputIterator<T, container>& operator++(int)
{
return *this;
}
container* _os;
};
int main()
{
Our_OutputIterator<int> os(cout);
vector<int> vec;
for (int i = 0; i < 10; ++i)
{
vec.push_back(i);
vec.push_back(i + 100);
}
copy(vec.begin(), vec.end(), os);
}
看起来好像没什么区别？其实这里面的区别大了。
STL迭代器的潜规则
让我们先从C#的接口谈起，相信大家对接口这个概念都不陌生。能被foreach遍历的类型，必须继承了IEnumerable这个接口。能够做比较运算的类型，必须继承了IComparable接口。接口，是个非常强的概念。它与类的虚函数相比，最大的不同就是：继承该接口后，必须要实现接口中的方法，而虚函数则不必。有了这层语法上的限制，那么我们在C#中定义我们的泛型方法时，就可以强制一些规定，便于我们操作传进来的泛型实参。比如我们要定义一个排序算法。既然是排序，首先就要求元素能够被比较，如果不能比较，那就只能呵呵了…下面贴代码。
public void FunnyQuickSort<T>(IList<T> list, Int32 right, Int32 left) where T : IComparable<T>
{
Int32 start = right, end = left;
if (start >= end)
{
return;
}
T @base = list[start];
while (start != end)
{
while (start < end && list[end].CompareTo(@base) >= 0)
{
end--;
}
list[start] = list[end];
while (start < end && list[start].CompareTo(@base) <= 0)
{
start++;
}
list[end] = list[start];
}
list[start] = @base;
FunnyQuickSort(list, right, start - 1);
FunnyQuickSort(list, start + 1, left);
}
通过用where这个方法，规定元素T的类型必须是可比较的，来限制用户程序员传入的类型。使用接口约束，不紧能方便我们在方法中做基于一定限制的逻辑操作，还能在需要的时候确定方法的返回类型以及一些类型的限定信息。可能后面这两个优点在C#中还不怎么明显，如果见识到STL为了这么简单的操作饶了多么大的弯，我们就能深刻体会到这种好处了。假设我们有这么个需求：需要返回一个两个迭代器（迭代器一个在前一个在后，能形成半开区间）间元素中的最大值。大家会怎么写这个方法？用C#,方法大概是这样：
我们可以返回一个T或者IComparable<T>。这是由于传进来的值的类型已经确定了是T。这是与C++最大的不同。在C++中，如果为通用的STL迭代器写一个算法，大概如下:
这时候，我们应该返回什么类型？我们甚至不知道这个迭代器指向的是什么类型！我们知道指向的值可以用*begin来表示，但是我们要怎么让编译器知道？这里可没有C#的委托限制，无法用委托来确定类型。大家想到怎么确定迭代器指向的类型了吗？没错，是利用函数模板的参数推到机制。我们要在里面再嵌入一层函数，即可得到迭代器指向的元素的类型。最后看起来代码像这样：
现在还剩一个问题了，最上层的Max应该返回什么类型？有两个方法可以确定：我们再为Max加一个泛型参数指明返回类型；再在模板中加一个插件。前一种很简单，不过不是很优雅，略过不谈。如何在模板中加插件？还记得我们前面所说的潜规则么？我们定义了五个“接口”，其中有一个是表示值类型的value_type。答案就在这！我们通过一个第三方的提取工具：iterator_traits，来获得返回的值类型。代码如下：
将迭代器的类型传入iterator_traits中，提取出定义该迭代器的时候定义的元素类型。这下所有的问题都解决了。是不是很优雅？当然，不要跟C#比。下面我们测试一下我们的代码：
#include <iostream>
#include <vector>
using namespace std;
template<typename inputIter>
typename iterator_traits<inputIter>::value_type Max(inputIter begin, inputIter end)
{
typedef typename iterator_traits<inputIter>::value_type type;
type val = *begin;
while (begin != end)
{
if (*begin > val)
{
val = *begin;
}
++begin;
}
return val;
}
int main()
{
vector<int> vec;
for (int i = 0; i < 10; ++i)
{
vec.push_back(i);
}
vec.push_back(100);
vec.push_back(1);
cout << Max(vec.begin(), vec.end()) << endl;
}
我们看到，由于C++少了接口这个语法级的概念，实现一个这么简单的方法，都要绕这么大一个弯！而且在调试代码的时候，模板出错的报错提示，是出了名的多！一个小问题可以引起大段的错误提示。其实上面的代码很容易出错，如果迭代器指向的类型无法做逻辑比较怎么办？比如将一个map的迭代器传进来，大家可以试一试！而C#从语法层面上将这些弊端都规避掉了。如果不符合接口限制，将会有优雅的提示信息。返回类型可以直接返回接口类型。我真心感觉吊炸天！如果不与C++比较，我是无法知道C#为我做了这么多工作！想到STL是上世纪的杰作，我很佩服当时为了解决这些问题而探索出的traits方法。而C#作为后来者，明显吸收了很多C++的精华。
通过容器和迭代器这两个组件，我们可以看到STL的构思之巧妙，通过一系列的潜规则，来实现了通用的目的。我们也看到了C#的方便之处。到目前的比较为止，C#的表现非常不错。但是，C#会一直这么拽吗？有句话说的好:“你不拽我们还可以做朋友…”。以我现在还和C#是朋友的现状来看……
我本来想以一篇来概括STL的，写了快10小时，发现还仅是写到第二个组件！现在只剩下一句话：欲知后事如何，请听下回分解！
总结
C#作为后来者，在语法层面上规避了很多STL遇到的问题。而STL的构思之妙，略窥一二。
参考资料
- 侯捷.STL源码剖析.武汉：华中科技大学出版社，2013
- Nicolai M. Josuttis.C++标准库.侯捷译.武汉：华中科技大学出版社，2011
- Jeffrey Richter. CLR via C#.周靖译.北京：清华大学出版社，2011