《C++标准程序库》笔记之二
本篇博客笔记顺序大体按照《C++标准程序库（第1版）》各章节顺序编排。
--------------------------------------------------------------------------------------------
6. STL 容器
6.1-1
本节讲述STL容器的共通能力。其中大部分都是必要条件，所有STL容器都必须满足那些条件。三个最最核心的能力是：
（1）所有容器提供的都是“value语意”而非“reference语意”。容器进行元素的安插操作时，内部实施的是拷贝操作，置于容器内。因此STL容器的每一个元素都必须能够被拷贝。如果你打算存放的对象不具有public copy构造函数，或者你要的不是副本（例如你要的是被多个容器共同容纳的元素），那么容器元素就只能是指针（指向对象）。参见上一篇博客C++标准程序库笔记之一，5.10节。
（2）总体而言，所有元素形成一个次序（oder）。也就是说，你可以依相同次序一次或多次遍历每个元素。每个容器都提供“可返回迭代器”的函数，运用那些迭代器你就可以遍历元素。这是STL算法赖以生存的关键接口。
（3）一般而言，各项操作并非绝对安全。调用者必须确保传给操作函数的参数符合需求。违反这些需求（例如使用非法索引）会导致未定义的行为。通常STL自己不会抛出异常。如果STL容器所调用的使用者自定操作抛出异常，会导致各不相同的行为。
容器的共通操作如表6.1
6.2 Vector
6.2-1 vector的容量之所以重要，有以下两个原因：
（1）一旦内存重新配置，和vector元素相关的所有references、pointers、iterators都会失效；
（2）内存重新配置很耗时间（安插就可能导致重新配置）。
vectors的容量不会缩减，我们便可确定，即使删除元素，其references、pointers、iterators也会继续有效，继续指向动作发生前的位置。然而安插操作却可能是references、pointers、iterators失效（内存重新配置）。
6.3 Deques
6.3-1 deque不支持对容量和内存重分配时机的控制。不过，deque的内存重分配优于vector，因为其内部结构显示，deque不必在内存重分配时复制所有元素。参见《STL源码剖析》
6.5 Sets 和 Multisets(红黑树)
有两种方式可以定义排序准则：
（1）例如： std::set<int, std::greater<int> > coll;
这种情况下，排序准则就是型别的一部分。因此型别系统确保“只有排序准则相同的容器才能被合并”。这是排序准则的通常指定法。更精确地说，第二参数是排序准则的型别，实际的排序准则是容器所产生的函数对象（function object，或称functor）。为了产生它，容器构造函数会调用“排序准则型别”的default构造函数。
1. 元素比较动作只能用于型别相同的容器。换言之，元素和排序准则必须有相同的型别，否则编译时期会产生型别方面的错误。如下：
std::set<float> c1; // sorting criterion -> std::less<> std::set<float, std::greater<float> > c2; // sorting criterion -> std::less<> ... if (c1 == c2) // ERROR:different types { ... }
2. 我们也可以使用自定之排序准则，这里同时也是把仿函数当做排序准则
#include <iostream> #include <string> #include <set> #include <algorithm> using namespace std; class Person { public: string firstname() const; string lastname() const; .... }; /* class for function predicate * - operator() returns whether a person is less than another person */ class PersonSortCriterion { public: bool operator() (const Person& p1, const Person& P2) const { /* a person is less than another person * - if the last name is less * - if the last name is equal and the first name is less */ return p1.lastname() < p1.lastname() || (!(p2.lastname() < p1.lastname()) && p1.firstname() < p2.firstname()); } }; int main() { // declare set type with special sorting criterion typedef set<Person, PersonSortCriterion> PersonSet; // create such a collection PersonSet coll; ... // do something with the elements PersonSet::iterator pos; for(pos = coll.begin(); pos != coll.end(); ++pos) { ... } ... }
（2）以构造函数参数定义之
这种情况下，同一个型别可以运用不同的排序准则（如下面程序例子），而排序准则的初始值或状态也可以不同。如果执行期才获得排序准则，而且需要用到不同的排序准则（但数据型别必须相同），此一方式可派上用场。
// 执行期指定排序准则，排序准则不同，但型别相同： #include <iostream> #include <set> using namespace std; // type for sorting criterion template <class T> class RuntimeCmp { public: enum cmp_mode {normal, reverse}; private: cmp_mode mode; public: // constructor for sorting criterion // - default criterion uses value normal RuntimeCmp(cmp_mode m = normal) : mode(m) { } // comparision of elements bool operator() (const T& t1, const T& t2) const { return mode == normal ? t1 < t2 : t2 < t1; } // comparision of sorting criteria bool operator== (const RuntimeCmp& rc) { return mode == rc.mode; } }; // type of a set that uses this sorting criterion typedef set<int, RuntimeCmp<int> > IntSet; // forward declaration void fill(IntSet& set); int main() { // create, fill, and print set with normal element order // - uses default sorting criterion IntSet coll1; fill(coll1); print_elements(coll1, "coll1 :"); // create sorting criterion with reverse element order RuntimeCmp<int> reverse_order(RuntimeCmp<int>::reverse); // create, fill, and print set with reverse element order IntSet coll2(reverse_order); fill(coll2); print_elements(coll2, "coll2 :"); // assign elements AND sorting criterion coll1 = coll2; coll1.insert(3); print_elements(coll1, "coll1 :"); // just to make sure... if(coll1.value_comp() == coll2.value_comp()) { cout << "coll1 and coll2 have same sorting criterion" << endl; } else { cout << "coll1 and coll2 have different sorting criterion" << endl; } } void fill(IntSet& set) { // fill insert elements in random order set.insert(4); set.insert(7); set.insert(5); set.insert(1); set.insert(6); set.insert(2); set.insert(5); } 输出： coll1：1 2 4 5 6 7 coll2：7 6 5 4 2 1 coll1：7 6 5 4 3 2 1 coll1 and coll2 have same sorting criterion
1. 在这个程序中，RuntimeCmp<> 是一个简单的template，提供“执行期间面对任意型别定义一个排序准则”的泛化能力。其default构造函数采用默认值normal，按升序排序；你也可以将RuntimeCmp<>::reverse传递给构造函数，便能按降序排序。
2. 注意，coll1 和 coll2 拥有相同的型别（包括元素的型别int，和排序准则的型别RuntimeCmp），该型别即fill() 函数的参数型别。再请注意，assignment操作符不仅赋值了元素，也赋值了排序准则（否则任何一个赋值操作岂不会轻易危及排序准则）。
3. 请注意，排序准则也被用于元素相等性检验工作，当采用缺省排序准则时，两元素的相等性检验语句如下：
if (!(elem1 < elem2 || elem2 < elem1))
这样做的好处有三：
a. 只需传递一个参数作为排序准则；
b. 不必针对元素型别提供operator==；
c. 你可以对“相等性”有截然相反的定义，不过当心造成混淆。
6.6 Maps 和 Multimaps
Maps和Multimaps 的元素型别key 和 T， 必须满足一下两个条件：
（1）key/value 必须具备assignable(可赋值的)和copyable(可复制的)性质；
（2）对排序准则而言，key必须是comparable(可比较的)。
Maps,Multimaps的排序准则定义和Sets,Multisets类似。同样，元素的比较动作也只能用于型别相同的容器。换言之，容器的key，value，排序准则都必须有相同的型别，否则编译期会产生型别方面的错误。
再次强调，更易型算法不得用于关联式容器，针对关联式容器，提供的迭代器类型为const iterator。
6.7 其他STL容器
6.7-1
STL 是个框架，除了提供标准容器，它也允许你使用其他数据结构作为容器。你可以使用字符串或数组作为STL容器，也可以自行撰写特殊容器以满足特性需求。如果你自行撰写容器，仍可从诸如排序、合并等算法中受益。这样的框架正是“开放性封闭（Open-Closed）”原则的极佳范例：允许扩展，谢绝修改。
下面是是你的容器“STL化”的三种不同方法：
（1）The invasive approach（侵入性作法） 直接提供STL容器所需接口。特别是诸如begin() 和 end() 之类的常用函数。这种作法需以某种特定方式编写容器，所以是侵入性的。
以string为例：
Strings可被视为以字符为元素的一种容器；字符构成序列，你可以在序列上来回移动遍历。因此，标准的string类别提供了STL容器接口。Strings也提供成员函数begin()和end()，返回随机存取迭代器，可用来遍历整个string。
（2）The noninvasive approach（非侵入性作法）
由你撰写或提供特殊迭代器，作为算法和特殊容器间的界面。此一作法是非侵入性的，它所需要的只是“遍历容器所有元素”的能力——这是任何容器都能以某种形式展现的能力。
以Array为例：
Arrays可被视为一种STL容器，但array并不是类别，所以不提供begin() 和 end() 等成员函数，也不允许存在任何成员函数。在这里，我们只能采用非侵入性作法或包装法。采取非侵入性作法很简单，你只需要一个对象，它能够透过STL迭代器接口，遍历数值的所有元素。事实上这样的对象早已存在，它就是普通指针。STL设计之初就决定让迭代器拥有和普通指针相同的接口，于是你可以将普通指针当成迭代器来使用。
（3）The wrapper approach（包装法） 将上述两种方法加以组合，我们可以写一个外套类别来包装任何数据结构，并显示出与STL容器相似的接口。
6.7-2 Hash Tables
Hash Tables数据结构可用于群集身上，非常重要，却因为提议太晚，未能包含于C++标准程序库——“我们必须在某个时间点中止引入新功能，开始关注细节，否则工作永无止境”。 Hash tables相关内容可以参见《STL源码剖析》。
6.9-1
表6.33提供了一份STL容器能力一览表。
------------------------------------------------------------------------------------------------------------------------------------
7 STL迭代器
STL迭代器相关详细内容参见《STL源码剖析》，这里只提几点注意事项：
（1）迭代器是一种“能够遍历某个序列内的所有元素”的对象(注意，迭代器是一种对象)。
（2）注意，Input迭代器只能读取元素一次。如果你复制Input迭代器，并使原Input迭代器和新产生的副本都先前读取，可能会遍历到不同的值（故而，如果两个Input迭代器占用同一个位置，则两者相等，但这并不意味它们存取元素时能够传回相同的值）。
（3）Output迭代器和Input迭代器相反，其作用是将元素值一个个写入。也就是说，你只能一个元素一个元素地赋新值，而且不能使用Output迭代器对同一序列进行两次遍历。这就好像将元素值写到“黑洞”里去，如果在相同位置上对着同一个“黑洞”进行第二次写入，不能确保这次写入的值会覆盖前一个值。
（4） 面对Output迭代器，我们无需检查是否抵达序列尾端，便可直接写入数据。事实上由于Output迭代器不提供比较操作，所以你不能将Output迭代器和尾端迭代器相比较。
（5）和Input迭代器及Output迭代器不同，Forward迭代器能多次指向同一群集中的同一元素，并能多次处理同一元素。同时，你必须在提领数据之前确保它有效。
（6）只有在面对Random Access Iterator时，你才能以 operator< 作为循环结束与否的判断准则（只有Random Access Iterator提供了 operator< 操作符），如“pos < coll.end() -1;”；否则，一般情况下我们使用不等号“pos != coll.end();”。
（7）尽可能优先选用前置式递增操作符（++iter）而不是后置式递增操作符（iter++），因为前者性能更好，参见C++小语法。
（8）迭代器的递增和递减操作有个问题。一般而言你可以递增或递减临时迭代器，但对于vectors和strings就不行，如下例子：
std::vector<int> coll; ... // sort, starting with the second element if (coll.size() > 1) { sort(++coll.begin(), coll.end() ); }
通常编译sort时会失败。但如果你换用deque取代vector，就可以通过编译。有时vector也可以通过编译——取决于vector的具体实作。
这种问题的产生原因是，vector的迭代器通常被实作为一般指针。要知道，C++不允许你修改任何基本型别（包括指针）的临时值（典型的右值），但对于struct和class则允许。因为如果迭代器被实作为一般指针，编译会失败；如果被实作为class，则编译可以成功。deques、lists、sets和maps总是能够通过编译，因为它们的迭代器不可能被实作为一般指针。至于vector，就要取决于实作手法了。
（9）Reverse（逆向）迭代器转换前后迭代器的逻辑位置发生了变化，具体参见《STL源码剖析》。容器的成员函数rbegin()和rend()各传回一个Reverse迭代器，它们就想begin()和end()一样，共同定义一个半开区间。
（10）有三种插入迭代器：back inserters、front inserters和general inserters。general inserters（或称general insert iterator）根据两个参数而初始化：1. 容器 2. 待安插位置。迭代器内部以“待安插位置”为参数，调用成员函数insert()。general inserters对于所有标准容器均适用，因为所有容器都有insert()成员函数。然而对关联式容器（sets和maps）而言，安插位置只是个提示，因为在这两种容器中，元素的真正位置视其实值（或键值）而定，安插位置如果使用不当反而可能导致比较糟糕的性能。
------------------------------------------------------------------------------------------------------------------------------------
8 仿函数（functors）——又名函数对象，function objects
仿函数的详细信息参见《STL源码剖析》以及上一篇博客C++标准程序库笔记之一 5.9-1 ，这里只提几点需要特别注意的地方：
（1）仿函数是passed by value（传值），不是passed by reference（传址），因此，算法并不会改变随参数而来的仿函数的状态。例如下面产生的两个序列都以1开始：
IntSequence seq(1); // integral sequence starting with value 1 // insert sequence beginning with 1 generate_n(back_inserter(coll), 9, seq); // insert sequence beginning with 1 again generate_n(back_inserter(coll), 9, seq);
将仿函数以by value方式传递（而非by reference方式传递）的好处是，你可以传递常量或暂时表达式。如果不这么设计，你就不可能传递IntSequence(1)这样的表达式。至于缺点就是，你无法改变仿函数的状态。算法当然可以改变仿函数的状态，但你无法存取并改变其最终状态，因为你所改变的只不过是仿函数的副本而已。然而有时候我们的确需要存取最终状态，因此，问题在于如何从一个算法中获得结果。 有两个办法可以从“运用了仿函数”的算法中获取“结果”或“反馈”：
1. 以by reference的方式传递仿函数；
2. 运用for_each()算法的返回值。
1. 为了能够以by reference 方式传递仿函数，你只需要在调用算法时，明白标示仿函数型别是个reference型别，如下：
#include <iosteam> #include <list> #include <algorithm> using namespace std; class IntSequence { private: int value; public: // constructor IntSequence(int initialValue) : value(initialValue) { } // function call, 无参 int operator() () { return value++; } }; int main() { list<int> coll; IntSequence seq(1); // integral sequence starting with 1 // insert values from 1 to 4 // - pass function object by reference(传址) // so that it will continue with 5 // 传址，改变了仿函数的状态 generate_n<back_insert_iterator<list<int> >, int, IntSequence&>(back_inserter(coll), // start 4, // number of elements seq); // generates values print_elements(coll); // insert values from 42 to 45 // 传值，不会改变原来仿函数的状态，改变的是仿函数的副本的状态 generate_n(back_inserter(coll), 4, IntSequence(42)); print_elements(coll); // continue with first sequence // - pass function object by value(传值) // so that it will continue with 5 again // 传值，不会改变原来仿函数的状态，改变的是仿函数的副本的状态 generate_n(back_inserter(coll), 4, seq); print_elements(coll); // continue with first sequence again // 传值，不会改变原来仿函数的状态，改变的是仿函数的副本的状态 generate_n(back_inserter(coll), 4, seq); print_elements(coll); } 输出： 1 2 3 4 1 2 3 4 42 43 44 45 1 2 3 4 42 43 44 45 5 6 7 8 1 2 3 4 42 43 44 45 5 6 7 8 5 6 7 8
2. for_each() 有一个其他算法概莫有之的绝技，那就是它可以返回仿函数。这样，你就可以通过for_each() 的返回值来获取仿函数的状态了。
#include <iostream> #include <vector> #include <algorithm> using namespace std; // function object to process the mean value class MeanValue { private: long num; // number of elements long sum; // sum of all element values public: // constructor MeanValue() : num(0), sum(0) { } // "function call" // - process one more element of the sequence void operator() (int elem) { num++; // increment count sum += elem; // add value } // return mean value double value() { return static_cast<double>(sum) / static_cast<double>(num); } }; int main() { vector<int> coll; // insert elements from 1 to 8 // for_each返回一个仿函数，保存在mv里面，记录了仿函数(的副本)改变之后的状态 MeanValue mv = for_each(coll.begin(), coll.end(), MeanValue()); cout << "mean value:" << mv.value() << endl; }
（2）判断式(Predicates)，就是返回布尔值（可转换为bool）的一个函数或仿函数。对STL而言，并非所有返回布尔值的函数都是合法的判断式，看下面的例子：
#include <iostream> #include <list> #include <algorithm> using namespace std; class Nth // function object that returns true for the nth call { private: int nth; // call for which to return true int count; // call counter public: Nth(int n) : nth(n), count(0) { } bool operator() (int) { return ++count == nth; } }; int main() { list<int> coll; // insert elements from 1 to 9 for(int i = 1; i <= 9; ++i) { coll.push_back(i); } print_elements(coll, "coll:"); // remove third element list<int>::iterator pos; pos = remove_if(coll.begin(), coll.end(), Nth(3)); coll.erase(pos, coll.end()); print_elements(coll, "nth removed:"); } 输出： coll: 1 2 3 4 5 6 7 8 9 nth removed: 1 2 4 5 7 8 9
有两个（而不是一个）元素——也就是第3个和第6个元素——被移除了！为什么会这样？因为该算法的一般实作版本，会于算法内部保留判断式的一份副本：
template <class ForwIter, class Predicate> ForwIter std::remove_if(ForwIter beg, ForwIter end, Predicate op) { beg = find_if(beg, end, op); if (beg == end) { return beg; } else{ ForwIter next = beg; return remove_copy_if(++next, end, beg, op); } }
1. remove_if 传进op，此时会复制一份op的副本供内部使用（副本1）；
2. find_if 传进副本1， 同样会根据副本1 复制一份副本2，供find_if内部使用；
3. 调用remove_copy_if时，可见的是副本1，此时的副本1并未被修改过（因为find_if使用的是根据副本1复制而来的副本2）。
也即，这个算法使用find_if来搜寻应被移除的第一个元素。然而，接下来它使用传进来的判断式op的副本去处理剩余元素。这时原始状态下的Nth再一次被使用，因而会移除剩余元素中的第3个元素，也就是整体的第6个元素。
这种行为不能说是一种错误，因为C++ Standard 并未明定判断式是否可被算法复制一份副本。因此，为了获得C++标准程序库的保证行为，你不应该传递一个“行为取决于被拷贝次数或被调用次数”的仿函数。也就是说，如果你以两个相同参数来调用一个单参数判断式，该判断式应该总是返回相同结果。换句话说，判断式不应该因为被调用而改变自身状态；判断式的副本应该和其正本有着相同状态。要做到这一点，你一定得保证不能因为函数调用而改变判断式的状态，你应当将 operotor() 声明为const成员函数。
上面的尴尬结果可以避免，只要使用另一种办法来代替find_if():
template <class ForwIter, class Predicate> ForwIter std::remove_if(ForwIter beg, ForwIter end, Predicate op) { // 不适用STL算法find_if，不会再额外复制多一份op的副本 while (beg != end && !op(*beg) ) { ++beg; } if (beg == end) { return beg; } else{ ForwIter next = beg; return remove_copy_if(++next, end, beg, op); } }
就我所知，目前的STL实作品中，只有remove_if()算法有这个问题。如果你换用remove_copy_if() ，就一切正常。然而如果考虑到可移植性，你就永远不该依赖任何实作细节，而应该总是将判断式的 operator() 声明为const成员函数。
（3）C++标准程序库提供了许多预定义仿函数，表8.1， 要使用这些仿函数，必须包含头文件<functional>. 同时也提供了各种类型的函数配接器，使用组合使用函数配接器，可以构造出非常复杂的表达式。参见《STL源码剖析》
------------------------------------------------------------------------------------------------------------------------------------
9 STL 算法 —— STL Algorithms
STL算法的详细信息参见《STL源码剖析》，这里只提几点需要特别注意的地方：
（1）STL算法采用覆盖模式而非安插模式。所以调用者必须保证目标区间拥有足够的元素空间。当然，你也可以运用特殊的安插型迭代器将覆盖模式改变为安插模式；
（2）再次强调，判断式不应该在函数调用过程中改变其自身状态；
（3）再次强调，关联式容器的元素被视为常数，惟其如此，你才不会在变动元素的时候有任何可能违反整个容器的排序准则。因此，你不可以将关联式容器当做变动性算法的目标区间；
（4）注意，移除算法只是在逻辑上移除元素，手段是：将不需被移除的元素往前覆盖应被移除的元素。因此它并不改变操作区间内的元素个数，而是返回逻辑上的新终点位置。至于是否使用这个位置进行诸如“实际移除元素”之类的操作，那是调用者的事情。任何算法，都不能（也无法）通过迭代器移除元素。
（5）Lists没有提供随机存取迭代器，所以不可以对它使用排序算法。然而lists本身提供了一个成员函数sort()，可用来对其元素排序。
（6）重排元素（Shuffling, 搅乱次序）
void random_suffle (RandomAccessIterator beg, RandomAccessIterator end) void random_suffle (RandomAccessIterator beg, RandomAccessIterator end, RandomFunc& op)
注意，op是一个non-const reference。所以你不可以将暂时数值或一般函数传进去（临时变量、函数返回值都是典型的右值，只有const reference可以指向它们）。
random_shuffle()的op参数需要使用non-const reference的原因：必须如此，因为典型的随机数产生器拥有一个局部状态（locate state）。旧式C函数如rand()是将其局部状态存储在某个静态变量中。但是这有一些缺点，例如这种随机数发生器本质上对于多线程（multi-threads）而言就不安全，而且你也不可能拥有两个各自独立的随机数流（streams）。如果使用仿函数，其区域状态被封装为一个或多个成员变量，那么就有了比较好的解决方案。这样一来，随机数产生器就不可能具备常数性，否则何以改变内部状态，何以产生新的随机数呢？不过你还是可以用by value方式传递随机数产生器，为什么非要以by non-const reference方式传递呢？是这样的，如果这么做（采用by value），每次调用都会在内部复制一个随机数产生器及其状态，结果，每次你传入随机数产生器，所得的随机数序列都一样，那又有何随机可言？所以，必须以by non-const reference方式传递op参数。
------------------------------------------------------------------------------------------------------------------------------------
10 特殊容器
（1）两大类：
1. 容器配接器（container adapters）：Stacks（栈），Queues（队列），Priority queues（优先队列），参见《STL源码剖析》
2. bitset特殊容器：Bitsets造出一个内含（bits）或布尔（boolean）值且大小固定的array。当你需要管理各式标志（flags），并以标志的任意组合在表现变量时，就可运用bitsets。C程序和传统C++程序通常使用型别long来作为bits array，再通过&, |, ~等位操作符（bit operators）操作各个位。Class bitset的优点在于可容纳任意个数的位（但不能动态改变），并提供各项操作。例如你可以对某个特定位置赋值一个位，也可以将bitsets作为由0和1组成的序列，进行读写。
注意，你不可以改变bitset内位的数量。这个数量的具体值是由template参数决定的。如果你需要一个可变长度的位容器，可考虑使用vector<bool>。
Class bitset定义于头文件<bitset>之中， 其中的class bitset是个template class，有一个template参数，用来指定位的数量：
#include <bitset> namespace std { template <size_t Bits> class bitset; }
在这里，template参数并不是一个型别，而是一个不带正负号的整数。注意，如果template参数不同，具现化所得的template型别就不同。换句话说，你只能针对位个数相同的bitsets进行比较和组合。
（2）Bitsets运用实例
1. 将Bitsets当做一组标志
这个例子展示如何运用bitsets来管理一组标志。每个标志都有一个由枚举型（enum）定义出来的值。该枚举值就表示位在bitset中的位置。举个例子，这些bits可以代表颜色，那么每一个枚举值都代表一种颜色。通过运用bitset，你可以管理一个变量，其中包含颜色的任意组合：
#include <bitset> #include <iostream> using namespace std; int main() { /* enumeration type for the bits * - each bit represents a color */ enum Color {red, yellow, green, blue, white, black,……numColors }; // create bitset for all bits/colors bitset<numColors> usedColors; // set bits for two colors usedColors.set(red); // 设置red（0号位置）上的bit位 usedColors.set(blue); // 设置blue（3号位置）上的bit位 // print some bitset data cout << "bitfield of used colors:" << usedColors << endl; cout << "number of used colors:" << usedColors.count() << endl; cout << "bitfield of unused colors:" << ~usedColors << endl; // if any color is used if (usedColors.any()) { // loop over all colors for (int c = 0; c < numColors; ++c) { //if the actual color is used if (usedColors[(Color)c]) { .... } } } }
2. 在I/O中利用Bitsets表示二进制
Bitsets一个强有力的特性就是可以在整数值和位序列之间相互转化，只要很简单地产生一个临时的bitset就可以办到：
#include <bitset> #include <iostream> #include <string> #include <limits> using namespace std; int main() { /* print some numbers in binary representation */ cout << "267 as binary short:" << bitset<numeric_limits<unsigned short>::digits>(267) << endl; cout << "267 as binary long:" << bitset<numeric_limits<unsigned long>::digits>(267) << endl; cout << "10, 000, 000 with 24 bits:" << bitset<24>(1e7) << endl; /* transform binary representation into integral number */ cout << "\"1000101011\" as number:" << bitset<100>(string("1000101011")).to_ulong() << endl; } // 程序可能输出如下（具体内容视平台上的short和long的位数量而定） 267 as binary short: 0000000100001011 267 as binary long: 00000000000000000000000100001011 10, 000, 000 with 24 bits: 100110001001011010000000 "1000101011" as number: 555
Class Bitsets更详细的信息参见相关源码和《STL源码剖析》