迭代器：
迭代器是类似指针的对象，STL算法利用它们对存储在容器中的对象序列进行遍历。
5种类别：1、输入迭代器   
         2、输出迭代器   
         3、前向迭代器   
         4、双向迭代器   
         5、随机访问迭代器 

常用的迭代器：
 istream_iterator< >输入流迭代器
 istreambuf_iterator<>输入流块迭代器
 ostream_iterator< >输出流迭代器
 ostreambuf_iterator<> 输出流块迭代器
 back_insert_iterator<Container> 使用Container的push_back成员函数
 front_insert_iterator<Container> 使用Container的push_front成员函数
 insert_iterator<Container> 使用Container的insert成员函数
 reverse_iterator<Container> 从后向前使用Container的insert成员函数
 const——iterator<>

二 分配算符（Allocators）

看看stl中默认的allocator：

 namespace std {
      template <class T>
      class allocator {
        public:
          //type definitions
          typedef size_t    size_type;   //represent the size of the largest object in the allocation model
          typedef ptrdiff_t difference_type; //The type for signed integral values that can represent the distance between any two pointers in the           

                                  //allocation model
          typedef T*        pointer;
          typedef const T*  const_pointer;
          typedef T&        reference;
          typedef const T&  const_reference;
          typedef T         value_type;  //The type of the elements

          //rebind allocator to type U
          template <class U>
          struct rebind {
              typedef allocator<U> other;
          };

          //return address of values
          pointer       address(reference value) const;
          const_pointer address(const_reference value) const;

          //constructors and destructor
          allocator() throw();
          allocator(const allocator&) throw();
          template <class U>
            allocator(const allocator<U>&) throw();
          ~allocator() throw();

          //return maximum number of elements that can be allocated
          size_type max_size() const throw();

          // allocate but don't initialize num elements of type T
          pointer allocate(size_type num,
                           allocator<void>::const_pointer hint = 0);

          // initialize elements of allocated storage p with value value
          void construct(pointer p, const T& value);

          // delete elements of initialized storage p
          void destroy(pointer p);

          // deallocate storage p of deleted elements
          void deallocate(pointer p, size_type num);
      };
   }

看了上面的allocator，我们已经基本知道他的用处，他一般用在容器中，作为容器的一个成员，但一般是用模版参数传入，这样才可以让我们换成我们自定义的allocator。

三 容器简介

STL标准容器类简介
标准容器类  说明
顺序性容器
vector   相当与数组，从后面快速的插入与删除，直接访问任何元素
deque   双队列，从前面或后面快速的插入与删除，直接访问任何元素
list   双链表，从任何地方快速插入与删除
关联容器
set   快速查找，不允许重复值
multiset  快速查找，允许重复值
map   一对一映射，基于关键字快速查找，不允许重复值
multimap  一对多映射，基于关键字快速查找，允许重复值
容器适配器
stack   后进先出
queue   先进先出
priority_queue  最高优先级元素总是第一个出列

所有标准库共有函数
默认构造函数  提供容器默认初始化的构造函数。
复制构造函数  将容器初始化为现有同类容器副本的构造函数
析构函数  不再需要容器时进行内存整理的析构函数
empty   容器中没有元素时返回true,否则返回false
max_size  返回容器中最大元素个数
size   返回容器中当前元素个数
operator=  将一个容器赋给另一个容器
operator<  如果第一个容器小于第二个容器，返回true，否则返回false，
operator<=  如果第一个容器小于或等于第二个容器，返回true，否则返回false
operator>  如果第一个容器大于第二个容器，返回true，否则返回false
operator>=  如果第一个容器大于或等于第二个容器，返回true，否则返回false
operator==  如果第一个容器等于第二个容器，返回true，否则返回false
operator!=  如果第一个容器不等于第二个容器，返回true，否则返回false
swap   交换两个容器的元素

其中operator>,operator>=,operator<,operator<=,operator==,operator!=均不适用于priority_queue

顺序容器和关联容器共有函数
begin  该函数两个版本返回iterator或const_iterator，引用容器第一个元素
end  该函数两个版本返回iterator或const_iterator,引用容器最后一个元素后面一位
rbegin  该函数两个版本返回reverse_iterator或const_reverse_iterator,引用容器最后一个元素
rend  该函数两个版本返回reverse_iterator或const_reverse_iterator，引用容器第一个元素前面一位
erase  从容器中清除一个或几个元素
clear  清除容器中所有元素

下表显示了顺序容器和关联容器中常用的typedef，这些typedef常用于变量、参数和函数返回值的一般性声明。
value_type  容器中存放元素的类型
reference  容器中存放元素类型的引用
const_reference 容器中存放元素类型的常量引用，这种引用只能读取容器中的元素和进行const操作
pointer  容器中存放元素类型的指针
iterator  指向容器中存放元素类型的迭代器
const_iterator  指向容器中存放元素类型的常量迭代器，只能读取容器中的元素
reverse_iterator  指向容器中存放元素类型的逆向迭代器，这种迭代器在容器中逆向迭代
const_reverse_iterator  指向容器中存放元素类型的逆向迭代器，只能读取容器中的元素
difference_type  引用相同容器的两个迭代器相减结果的类型（list和关联容器没有定义operator-）
size_type  用于计算容器中项目数和检索顺序容器的类型（不能对list检索）

四 容器的比较

vector  （连续的空间存储,可以使用【】操作符）快速的访问随机的元素，快速的在末尾插入元素，但是在序列中间岁间的插入，删除元素要慢，而且如果一开始分配的空间不够

的话，有一个重新分  配更大空间，然后拷贝的性能开销
deque （小片的连续，小片间用链表相连，实际上就是一个每小片指针的数组，因为知道类型，所以还是可以使用【】，只是速度没有vector快）快速的访问随机的元素，快速

的在开始和末尾插入元素，随机的插入，删除元素要慢，空间的重新分配要比vector快
list   （每个元素间用链表相连）访问随机元素不如vector快，随机的插入元素比vector快，对每个元素分配空间，所以不存在空间不够，重新分配的情况

set 内部元素唯一，用一棵平衡树结构来存储，因此遍历的时候就排序了，查找也比较快的哦。
map 一对一的映射的结合，key不能重复。
multiset
multimap

stack 适配器，必须结合其他的容器使用
queue 是受限制的dequem
vector<bool> 与bitset<> ,前面的可以动态改变长度。
priority_queue 插入的元素就有优先级顺序，top出来的就是优先级最高的了
valarray 专门进行数值计算的，增加特殊的数学函数。

接下来，stl的输入输出流

STL算法学习，小结如下：

前提:

下载stl源码：  http://www.sgi.com/tech/stl/download.html
打开网页：     http://www.sgi.com/tech/stl/stl_index.html

一   函数对象： 因为很多的算法中多使用了函数对象

二元函数对象，V1和V2为输入，V3为结果

plus<T>:
  transform(V1.begin(), V1.end(), V2.begin(), V3.begin(),plus<double>());

其他的二元函数对象：minus,multiples,divieds,modulus.

二元断言函数对象，使用时需要bind2nd（）或bind1st（）来绑定比较对象。

less<T>:
  find_if(L.begin(), L.end(), bind2nd(less<int>(), 0));

其他的二元断言函数：equal_to,notequal_to,greater,greater_equal,less_equal,logical_and,logical_or

二元逻辑函数

binary_negate:
const char* wptr = find_if(str, str + MAXLEN,
                           compose2(not2(logical_or<bool>()),
                                    bind2nd(equal_to<char>(), ' '),
                                    bind2nd(equal_to<char>(), '\n')));

一元函数对象

negate：
transform(V1.begin(), V1.end(), V2.begin(),
          negate<int>());

一元断定函数对象

logical_not:
  transform(V.begin(), V.end(), V.begin(), logical_not<bool>());

一元逻辑函数

unary_negate:

二   函数对象发生器：主要用来填充序列。


产生不重复的随机数：
// Generate unique random numbers from 0 to mod:
class URandGen {
  std::set<int> used;
  int limit;
public:
  URandGen(int lim) : limit(lim) {
    srand(time(0));
  }
  int operator()() {
    while(true) {
      int i = int(rand()) % limit;
      if(used.find(i) == used.end()) {
        used.insert(i);
        return i;
      }
    }
  }
};

const int sz = 10;
const int max = 50;
vector<int> x(sz), y(sz), r(sz);
//An integer random number generator:
URandGen urg(max);
generate_n(x.begin(), sz, urg);

三 函数对象适配器 ： 将函数转化为函数对象

ptr_fun:一般函数适配器

一元实例：
transform(first, last, first,
          compose1(negate<double>, ptr_fun(fabs)));

二元实例：
list<char*>::iterator item =
              find_if(L.begin(), L.end(),
                      not1(binder2nd(ptr_fun(strcmp), "OK")));

not1：对一元的断定函数对象取反的适配器。

not2: 对二元的断定函数对象取反的适配器。

mem_fun与mem_fun_ref：类成员函数的适配器,区别是一个需要指针，而另一个仅需要一般对象。如下：
shape是一个指针变量，则foreach(v.begin(),v.end(),mem_fun(&shape::draw));
但如果shape是一般的变量，不是指针，则foreach（v.begin(),v.end(),mem_fun_ref(&shape::draw)）；

四   算法：

拷贝：
copy（）
reverse_copy()
rotate_copy()
remove_copy()  拷贝不等于某值的元素到另一个序列。
remove_copy_if() 拷贝符合条件的到另一个序列。

填充和生成：
fill()
fill_n() 填充序列中的n个元素。
generate（）为序列中的每个元素调用gen（）函数。

排列：
next_permuttion() 后一个排列。
prev_permutation()

partition() 划分，将满足条件的元素移动到序列的前面。
stable_partition()

查找和替换：
find（）
binary_search() 在一个已经有顺序的序列上查找。
find_if()
search() 检查第二个序列是否在第一个序列中出现，且顺序相同。

删除：注意必须调用erase（）来真正删除
remove（）
unique（）删除相邻重复元素，最好现排序。

合并序列：
merge（）

数值算法：
accumulate（） 对序列的每个元素进行运算后求和。
transform（） 也可以对每个元素进行运算。
计数：
size（）总个数。
count（）等于某值的元素个数。

adjacent_difference 序列中的后一个减前与他相邻的前一个得到新的序列。

adiacent_find

五   所有的算法：

     accumlate ： iterator 对标志的序列中的元素之和，加到一个由 init 指定的初始值上。重载的版本不再做加法，而是传进来的二元操作符被应用到元素上。
adjacent_different ：创建一个新序列，该序列的每个新值都代表了当前元素与上一个元素的差。重载版本用指定的二元操作计算相邻元素的差。
adjacent_find ：在 iterator 对标志的元素范围内，查找一对相邻的重复元素，如果找到返回一个 ForwardIterator ，指向这对元素的第一个元素。否则返回 last 。重载版本使用输入的二元操作符代替相等的判断。
binary_search ：在有序序列中查找 value ，如果找到返回 true 。重载的版本使用指定的比较函数对象或者函数指针来判断相等。
copy ：复制序列。
copy_backward ：除了元素以相反的顺序被拷贝外，别的和 copy 相同。
count ：利用等于操作符，把标志范围类的元素与输入的值进行比较，并返回相等元素的个数。
count_if ：对于标志范围类的元素，应用输入的操作符，并返回结果为 true 的次数。
equal ：如果两个序列在范围内的元素都相等，则 equal 返回 true 。重载版本使用输入的操作符代替了默认的等于操作符。
equal_range ：返回一对 iterator ，第一个 iterator 表示由 lower_bound 返回的 iterator ，第二个表示由 upper_bound 返回的 iterator 值。
fill ：将输入的值的拷贝赋给范围内的每个元素。
fill_n ：将输入的值赋值给 first 到 frist+n 范围内的元素。
find ：利用底层元素的等于操作符，对范围内的元素与输入的值进行比较。当匹配时，结束搜索，返回该元素的一个 InputIterator 。
find_if ：使用输入的函数替代了等于操作符执行了 find 。
find_end ：在范围内查找“由输入的另外一个 iterator 对标志的第二个序列”的最后一次出现。重载版本中使用了用户输入的操作符替代等于操作。
find_first_of ：在范围内查找“由输入的另外一个 iterator 对标志的第二个序列”中的任意一个元素的第一次出现。重载版本中使用了用户自定义的操作符。
for_each ：依次对范围内的所有元素执行输入的函数。
generate ：通过对输入的函数 gen 的连续调用来填充指定的范围。
generate_n ：填充 n 个元素。
includes ：判断 [first1, last1) 的一个元素是否被包含在另外一个序列中。使用底层元素的 <= 操作符，重载版本使用用户输入的函数。
inner_product ：对两个序列做内积 ( 对应的元素相乘，再求和 ) ，并将内积加到一个输入的的初始值上。重载版本使用了用户定义的操作。
inner_merge ：合并两个排过序的连续序列，结果序列覆盖了两端范围，重载版本使用输入的操作进行排序。
iter_swap ：交换两个 ForwardIterator 的值。
lexicographical_compare ：比较两个序列。重载版本使用了用户自定义的比较操作。
lower_bound ：返回一个 iterator ，它指向在范围内的有序序列中可以插入指定值而不破坏容器顺序的第一个位置。重载函数使用了自定义的比较操作。
max ：返回两个元素中的较大的一个，重载版本使用了自定义的比较操作。
max_element ：返回一个 iterator ，指出序列中最大的元素。重载版本使用自定义的比较操作。
min ：两个元素中的较小者。重载版本使用自定义的比较操作。
min_element ：类似与 max_element ，不过返回最小的元素。
merge ：合并两个有序序列，并存放到另外一个序列中。重载版本使用自定义的比较。
mismatch ：并行的比较两个序列，指出第一个不匹配的位置，它返回一对 iterator ，标志第一个不匹配的元素位置。如果都匹配，返回每个容器的 last 。重载版本使用自定义的比较操作。
next_permutation ：取出当前范围内的排列，并将其重新排序为下一个排列。重载版本使用自定义的比较操作。
nth_element ：将范围内的序列重新排序，使所有小于第 n 个元素的元素都出现在它前面，而大于它的都出现在后面，重载版本使用了自定义的比较操作。
partial_sort ：对整个序列做部分排序，被排序元素的个数正好可以被放到范围内。重载版本使用自定义的比较操作。
partial_sort_copy ：与 partial_sort 相同，除了将经过排序的序列复制到另外一个容器。
partial_sum ：创建一个新的元素序列，其中每个元素的值代表了范围内该位置之前所有元素之和。重载版本使用了自定义操作替代加法。
partition ：对范围内元素重新排序，使用输入的函数，把计算结果为 true 的元素都放在结果为 false 的元素之前。
prev_permutation ：取出范围内的序列并将它重新排序为上一个序列。如果不存在上一个序列则返回 false 。重载版本使用自定义的比较操作。
random_shuffle ：对范围内的元素随机调整次序。重载版本输入一个随机数产生操作。
remove ：删除在范围内的所有等于指定的元素，注意，该函数并不真正删除元素。内置数组不适合使用 remove 和 remove_if 函数。
remove_copy ：将所有不匹配的元素都复制到一个指定容器，返回的 OutputIterator 指向被拷贝的末元素的下一个位置。
remove_if ：删除所有范围内输入操作结果为 true 的元素。
remove_copy_if ：将所有不匹配的元素拷贝到一个指定容器。
replace ：将范围内的所有等于 old_value 的元素都用 new_value 替代。
replace_copy ：与 replace 类似，不过将结果写入另外一个容器。
replace_if ：将范围内的所有操作结果为 true 的元素用新值替代。
replace_copy_if ：类似与 replace_if ，不过将结果写入另外一个容器。
reverse ：将范围内元素重新按反序排列。
reverse_copy ：类似与 reverse ，不过将结果写入另外一个容器。
rotate ：将范围内的元素移到容器末尾，由 middle 指向的元素成为容器第一个元素。
rotate_copy ：类似与 rotate ，不过将结果写入另外一个容器。
search ：给出了两个范围，返回一个 iterator ，指向在范围内第一次出现子序列的位置。重载版本使用自定义的比较操作。
search_n ：在范围内查找 value 出现 n 次的子序列。重载版本使用自定义的比较操作。
set_difference ：构造一个排过序的序列，其中的元素出现在第一个序列中，但是不包含在第二个序列中。重载版本使用自定义的比较操作。
set_intersection ：构造一个排过序的序列，其中的元素在两个序列中都存在。重载版本使用自定义的比较操作。
set_symmetric_difference ：构造一个排过序的序列，其中的元素在第一个序列中出现，但是不出现在第二个序列中。重载版本使用自定义的比较操作。
set_union ：构造一个排过序的序列，它包含两个序列中的所有的不重复元素。重载版本使用自定义的比较操作。
sort ：以升序重新排列范围内的元素，重载版本使用了自定义的比较操作。
stable_partition ：与 partition 类似，不过它不保证保留容器中的相对顺序。
stable_sort ：类似与 sort ，不过保留相等元素之间的顺序关系。
swap ：交换存储在两个对象中的值。
swap_range ：将在范围内的元素与另外一个序列的元素值进行交换。
transform ：将输入的操作作用在范围内的每个元素上，并产生一个新的序列。重载版本将操作作用在一对元素上，另外一个元素来自输入的另外一个序列。结果输出到指定的容器。
unique ：清除序列中重复的元素，和 remove 类似，它也不能真正的删除元素。重载版本使用了自定义的操作。
unique_copy ：类似与 unique ，不过它把结果输出到另外一个容器。
upper_bound ：返回一个 iterator ，它指向在范围内的有序序列中插入 value 而不破坏容器顺序的最后一个位置，该位置标志了一个大于 value 的值。重载版本使用了输入的比较操作。
堆算法： C++ 标准库提供的是 max-heap 。一共由以下 4 个泛型堆算法。
make_heap ：把范围内的元素生成一个堆。重载版本使用自定义的比较操作。
pop_heap ：并不是真正的把最大元素从堆中弹出，而是重新排序堆。它把 first 和 last-1 交换，然后重新做成一个堆。可以使用容器的 back 来访问被“弹出“的元素或者使用 pop_back 来真正的删除。重载版本使用自定义的比较操作。
push_heap ：假设 first 到 last-1 是一个有效的堆，要被加入堆的元素在位置 last-1 ，重新生成堆。在指向该函数前，必须先把元素插入容器后。重载版本使用指定的比较。
sort_heap ：对范围内的序列重新排序，它假设该序列是个有序的堆。重载版本使用自定义的比较操作。

接下来： STL容器学习

孟岩
侯捷注：本文承作者孟岩先生应允，
转载於此以飨台湾读者，非常感谢。

未得孟岩先生之同意，任何人请勿将此文再做转载。

以下红色为译注，紫色为侯捷个人认为宜再斟酌之处。
浅蓝色是侯捷个人阅读时的神秘标记。

本繁体文系直接转码，并未将大陆惯用术语转换为台湾惯用术语。

--------------------------------------------------------------------------------

STL是一个标准，各商家根据这个标准开发了各自的STL版本。而在这形形色色的STL版本中，SGI STL无疑是最引人瞩目的一个。这当然是因为这个STL产品系出名门，其设计和编写者名单中，Alexander Stepanov和Matt Austern赫然在内，有两位大师坐镇，其代码水平自然有了最高的保证。SGI STL不但在效率上一直名列前茅，而且完全依照ISO C++之规范设计，使用者尽可放心。此外，SGI STL做到了thread-safe, 还体贴地为用户增设数种组件，如hash, hash_map,hash_multimap, slist和rope容器等等。因此无论在学习或实用中，SGI STL应是首选。

无奈，SGI STL本质上是为了配合SGI自作的UNIX变体IRIX所量身定做，其它平台上的C++编译器想使用SGI STL，都需要一番周折。着名的GNU C++虽然也使用 SGI STL，但在发行前已经过调试整合。普通的用户，特别是Windows平台上的BCB/VC用户要想使自己的C++编译器与SGI STL共同工作，可不是一件容易的事情。好在英雄总能及时出现，俄国人Boris Fomitchev注意到这个问题之後，建立了一个free的项目，称为STLport，旨在将SGI STL的基本代码移植到各种主流编译环境中，使各种编译器的用户都能够享受到SGI STL带来的先进之处。STLport 发展过程中，曾受到Matt Austern的亲切指导，发展到今天，已经比较成熟。最新的STLport 4.0，可以从www.stlport.org免费下载，zip文件体积约1.2M, 可以支持向各种主流C++编译环境的移植。BCB及VC当然算是主流的编译环境，自然得到STLport的关照。但据笔者实践来看，配置过程中还有一些障碍需要跨越，本文即旨在详细指导读者在Borland C++Builder 5.5及Visual C++ 6.0 环境中配置STLport。

首先请从www.stlport.org中下载STLport 4.0的ZIP文件，文件名stlport-4.0.zip. 然後利用WinZip等工具展开。生成stlport-4.0目录，该目录中有且仅有一个子目录，名称亦为stlport-4.0，不妨将整目录拷贝到你以为合适的位置，然後改一个合适的名字，例如配合BCB的，可以叫STL4BC，等等。

下面分成BCB/VC两种情形来描述具体过程。

Borland C++Builder 5
Borland C++Builder5中所带之C++编译器是5.5版本，在当前较主流的Windows平台编译器中，对於ISO C++ Standard的支持是最完善的。用它来配合SGI STL相当方便，也是笔者推荐之选。没有此开发工具的读者，可以到www.borland.com上免费下载Borland C++ 5.5编译器的一个精装版，该精装版体积为8.54M，名称 freecommandlinetools1.exe，乃一自解压安装文件。可在Windows中执行它，
安装到合适的目录中。展开後体积50M。

以下描述中，假定你使用的Windows装在C:\Windows目录。如果你有BCB5，我假设装在C:\Program Files\Borland\CBuilder5；如果你没有BCB5，而是使用上述的精简版BCC，则假设安装在C:\BCC55目录中，而STLport原包置于C:\STL4BC。

C:\STL4BC中应该有以下内容：
<目录> doc
<目录> lib
<目录> src
<目录> stlport
<目录> test
文件 ChangLog
文件 Install
文件 Readme
文件 Todo

同时确保C:\Program Files\Borland\CBuilder5\Bin或C:\BCC55\Bin在你的Path环境变量中。

笔者推荐你在安装之前读一读Install文件，其中会讲到如何避免使用SGI提供的iostream库。如果你不愿意使用SGI iostream，STLport会在原来编译器自带的iostream库外加一个 wrapper，使之能与SGI STL共同合作。不过SGI提供的iostream库标准化程度好，跟本家的 STL代码配合起来速度也快些，所以笔者实在想不出什麽理由不使用它，在这里假定大家跟笔者一样，乐于使用SGI iostream库。有不同看法者尽可以按照Install文件的说法调整。

下面一步步来：

0. 本次配置任务均在DOS命令状态下完成，请先从“开始”-->“附件”菜单中选中MS-DOS方式，打开一个DOS窗口。

1. 到C:\Program Files\Borland\CBuilder5\bin中，利用你顺手的文本编辑器修改两个文件：

file1: bcc32.cfg，改成：

-I"C:\STL4BC\stlport";\
"C:\Program Files\Borland\CBuilder5\Include";"C:\Program Files\Borland\CBuilder5\Include\vcl"
-L"C:\STL4BC\LIB";"C:\Program Files\Borland\CBuilder5\Lib";"C:\Program Files\Borland\CBuilder5\Lib\obj";"C:\Program Files\Borland\CBuilder5\Lib\release"

上面为了方便阅读用"\"符号将很长的一行折行，实际文件应该只有两行。

file2: ilink32.cfg，改成：

-L"C:\STL4BC\LIB";"C:\Program Files\Borland\CBuilder5\Lib";"C:\Program Files\Borland\CBuilder5\Lib\obj";"C:\Program Files\Borland\CBuilder5\Lib\release"

在C:\BCC55\BIN目录中，不存在这两个文件，请你自己用文字编辑器手工做出这两个文件来，内容与上面有所不同，如下

file1: bcc32.cfg，内容：

-I"C:\STL4BC\stlport";"C:\BCC55\Include";
-L"C:\STL4BC\LIB";"C:\BCC55\Lib";

file2: ilink32.cfg，内容：

-L"C:\STL4BC\LIB";"C:\BCC55\Lib";

2. 进入到C:\STL4BC\SRC目录中。

3. 执行命令copy bcb5.mak Makefile

4. 执行命令make clean all

这个命令会执行很长时间，尤其在老旧机器上，可能运行30分钟以上。屏幕不断地在显示
工作情况，有时你会看到好像计算机在反复地做同样几件事，请保持耐心，这实际上是在
以不同编译开关建立不同性质的目标库。

5. 经过一段漫长的编译之後， 终於结束了。现在你再执行命令 make install 这次需要的时间不长。

6. 来到C:\STL4BC\LIB目录，执行
copy *.dll c:\windows\system;

7. OK，大功告成。下面一步应该是检验一下事不是真的用上了SGI STL。rope是SGI STL提供的一个特有容器，专门用来对付超大规模字符串(string是细弦，而rope是粗绳子，可以想见rope的能力有多强)。

下面这个程序有点暴殓天物，不过也可以做一个小试验了：

//issgistl.cpp
#include <iostream>
#include <rope>

using namespace std;

int main()
{
    // crope就是容纳char类型字符的rope容器
    crope bigstr1("It took me about one hour ");
    crope bigstr2("to plug the STLport into Borland C++!");
    crope story = bigstr1 + bigstr2;
    cout << story << endl;
    return 0;
}
//~issgistl.cpp

编译 bcc32 issgistl.cpp

咦，怪哉，linker报告说找不到stlport_bcc_static.lib，到C:\STL4BC\LIB看个究竟，确实并没有这个文件，倒是有一个stlport_bcb55_static.lib。笔者发现这是STLport的一个小问题，需要将库文件的名字做一点改动：

copy stlport_bcb55_static.lib stlport_bcc_static.lib

这做法比较稳妥，原来的stlport_bcb55_static.lib也保留下来。以其他选项进行编译时，还可能会遇到类似的问题，只要照葫芦画瓢该名字就没问题了。

现在再编译，应该没问题了。可能有一些warning，没有关系。只要能运行，就说明rope容器起作用了，也就是说你的SGI STL开始工作了。

Microsoft Visual C++ 6.0:
Microsoft Visual C++ 6.0是当今Windows下C++编译器主流中的主流，但是对於ISO C++的支持并不尽如人意。其所配送的STL性能也比较差。不过既然是主流，STLport自然不敢怠慢，下面介绍VC中的STLport配置方法。

以下描述中，假定你使用的Windows装在C:\Windows目录。VC装在 C:\Program Files\Microsoft Visual Studio\VC98；而STLport原包置于C:\STL4VC。

C:\STL4VC中应该有以下内容：

<目录> doc
<目录> lib
<目录> src
<目录> stlport
<目录> test
文件 ChangLog
文件 Install
文件 Readme
文件 Todo

同时确保C:\Program Files\Microsoft Visual Studio\VC98\bin在你的Path环境变量中。

下面一步步来：

0. 本次配置任务均在DOS命令状态下完成，请先从“开始”-->“附件”菜单中选中MS-DOS方式，打开一个DOS窗口。

1. 到C:\Program Files\Microsoft Visual Studio\VC98中，利用你顺手的文本编辑器修改两个文件vcvars32.bat，其中有两行

set INCLUDE=%MSVCDir%\ATL\INCLUDE;%MSVCDir%\INCLUDE;%MSVCDir%\MFC\INCLUDE;%INCLUDE%
set LIB=%MSVCDir%\LIB;%MSVCDir%\MFC\LIB;%LIB%

改成：

set INCLUDE=C:\STL4VC\stlport;%MSVCDir%\ATL\INCLUDE;%MSVCDir%\INCLUDE;%MSVCDir%\MFC\INCLUDE;%INCLUDE%
set LIB=C:\STL4VC\lib;%MSVCDir%\LIB;%MSVCDir%\MFC\LIB;%LIB%

上面为了方面阅读用 "\" 符号将过长的一行折成两行，实际文件中还是一行。

修改完毕後保存，然後执行命令vcvars32。一切顺利的话应该给出一行结果：

Setting environment for using Microsoft Visual C++ tools.

如果你预设的DOS环境空间不足，这个BAT文件执行中可能导致环境空间overflow，此时应该在DOS窗口的“属性”对话框中找到“内存”页，修改“初始环境”ComboBox，改为一个较大的值，如1280或2048。然後再次开一个DOS窗口，运行vcvars32.bat。

2. 进入到C:\STL4VC\SRC目录中。

3. 执行命令copy vc6.mak Makefile

4. 执行命令make clean all

如果说BCB编译STLport的时间很长，那麽VC编译STLport的过程就更加漫长。屏幕反反复复地显示似乎是同样的内容，请务必保持耐心，这实际上是在以不同编译开关建立不同性质的目标库。

5. 经过一段漫长的编译之後， 终於结束了。现在你再执行命令

make install

这次需要的时间不那麽长，但也要有点耐心。

6. OK，大功告成。下面一步应该是检验一下事不是真的用上了SGI STL。跟上面BCB的过程差不多，找一个使用了SGI STL特性的程序，比如使用rope, slist, hash_set, hash_map等容器的程序来编译。注意，编译时务必使用下面的格式：

cl /GX /MT program.cpp

SGI STL中大量使用try..throw..catch，VC缺省情况下不支持此语法，/GX是要求VC++ Compiler打开对异常处理语法的支持。/MT则是要求VC的linker本程序obj文件与libcmt.lib连接在一起，因为SGI STL是thread-safe的，必须以multi-thread形式运行。

若要在图形界面中使用SGI STL，可在VC中调整Project-->Setting(Alt+F7), 设置编译选项，注意使用/MT和/GX，并且引入选项/Ic:\stl4vc\stlport及/libpath:c:\stl4vc\lib。

整个过程在笔者的老式Pentium 150机器上运行了超过3小时，读者的机器想必快得多，但也必然会花去出乎你意料的时间。全部完成後，C:\STL4VC这个目录的体积也由原来的区区4.4M膨胀到可怕的333M，当然这其中有300M是编译过程中产生的.obj文件，如果你确信自己的STLport工作正常的话，可以删掉它们，省出硬盘空间。不过这样一来，下次若再编译，就只好再等很长时间。

另外，据笔者勘察，STLport 4.0所使用的SGI STL并非最新问世的SGI STL3.3版本，不知道把SGI STL3.3的代码导入STLport会有何效果，有兴趣的读者不妨一试。

大致情形就是这样，现在，套用STLport自带文件的结束语：

Have fun!

孟岩
2001-3-11