STL 容器适配器小结

容器适配器（container adapter）

注：内容主要总结自 C++ Standard Library 第二版。

C++ 标准库还包含一些满足特殊需求而设计的容器，它们提供非常简单的接口。这些容器被归类为容器适配器，它们是由标准 STL 容器构建的。有三种标准的容器适配器：

• stack
• queue
• priority_queue

还有一种特殊的容器适配器：

• bitset

1.1  stack（堆栈）

位于头文件 stack 中，定义如下：

namespace std {
   template <class T,
             class Container = deque<T> >
             class stack;
}

• 第一个 template 参数代表元素类型
• 带有默认值的第二个 template 参数用来定义 stack 内部用来存放元素的实际容器，默认为 deque

核心接口

• push ()
• pop ()
• top ()

详细定义

namespace std {
      template <class T, class Container = deque<T> >
      class stack {
        public:
          typedef typename Container::value_type value_type;
          typedef typename Container::size_type  size_type;
          typedef          Container             container_type;
          protected:
            Container c;     // container
          public:
            explicit stack(const Container& = Container());

            bool        empty() const             { return c.empty(); }
            size_type   size()    const           { return c.size(); }
            void push   (const value_type& x)     { c.push_back(x); }
            void        pop()                     { c.pop_back(); }
            value_type& top()                     { return c.back(); }
            const value_type& top() const         { return c.back(); }
      };

      template <class T, class Container>
        bool operator==(const stack<T, Container>&,
                        const stack<T, Container>&);
      template <class T, class Container>
        bool operator< (const stack<T, Container>&,
                        const stack<T, Container>&);
      ...// (other comparison operators)
}

从 protect 区域可以看出，类内部仅有一个 Container 类型的对象 c。仅适用该对象便可实现 stack <>。

实际上我们也可以适用类似的方法（composition，组合）的方式，来通过 STL 容器实现自己的数据结构。

1.2  queue（队列）

位于头文件 queue 中，class queue 定义如下：

namespace std {
       template <class T,
                 class Container = deque<T> >
       class queue;
}

• 第一个 template 参数代表元素类型
• 带有默认值的第二个 template 参数用来定义 queue 内部用来存放元素的实际容器，默认为 deque

核心接口

实际上只要容器有 push_back ()、front ()、back ()、pop_front ()操作就可以作为 queue 的容器，在 queue 内部只是把这些操作转化而已： 

• push () -- push_back ()
• front () -- front ()
• back () -- back ()
• pop () -- pop_front ()

详细定义

namespace std {
       template <class T, class Container = deque<T> >
       class queue {
         public:
           typedef typename Container::value_type value_type;
           typedef typename Container::size_type size_type;
           typedef          Container            container_type;
         protected:
           Container c;     // container
         public:
           explicit queue(const Container& = Container());

           bool     empty() const              { return c.empty(); }
           size_type size() const              { return c.size(); }
           void     push(const value_type& x)  { c.push_back(x); }
           void     pop()                      { c.pop_front(); }
           value_type&      front()            { return c.front(); }
           const value_type& front()const      { return c.front(); }
           value_type&       back()            { return c.back(); }
           const value_type& back() const      { return c.back(); }
       };

       template <class T, class Container>
         bool operator==(const queue<T, Container>&,
                         const queue<T, Container>&);
       template <class T, class Container>
         bool operator< (const queue<T, Container>&,
                         const queue<T, Container>&);
         //(other comparison operators)
}

1.3  priority_queue（优先队列）

位于头文件 queue 中，定义如下：

namespace std {
       template <class T,
                 class Container = vector<T>,
                 class Compare = less<typename Container::value_type> >
       class priority_queue;
}

• 第一个 template 参数代表元素类型
• 带有默认值的第二个 template 参数用来定义 priority_queue 内部用来存放元素的实际容器，默认为 vector
• 带有默认值的第三个 template 参数定义“用来查找下一个最高优先级元素”的排序准则，默认以 < 作为比较标准（大顶堆）

核心接口

• push ()
• top ()
• pop ()

只要容器支持 random-access iterator 和 front ()、push_back ()、pop_back ()，就可以作为 priority_queue 的容器。由于 priority_queue 要用到 STL heap 算法，所以容器必须支持 random-access iterator。

详细定义

namespace std {
      template <class T, class Container = vector<T>,
                class Compare = less<typename Container::value_type> >
      class priority_queue {
        public:
          typedef typename Container::value_type value_type;
          typedef typename Container::size_type  size_type;
          typedef          Container             container_type;
        protected:
          Compare comp; // sorting criterion
          Container c;  // container
        public:
          // constructors
        explicit priority_queue(const Compare& cmp = Compare(),
                                const Container& cont = Container())
         : comp(cmp), c(cont) {
            make_heap(c.begin(),c.end(),comp);
        }

        template <class InputIterator>
        priority_queue(InputIterator first, InputIterator last,
                       const Compare& cmp = Compare(),
                       const Container& cont = Container())
         : comp(cmp), c(cont) {
            c.insert(c.end(),first,last);
            make_heap(c.begin(),c.end(),comp);
         }

         void push(const value_type& x); {
            c.push_back(x);
            push_heap(c.begin(),c.end(),comp);
         }
         void pop() {
            pop_heap(c.begin(),c.end(),comp);
            c.pop_back();
         }

         bool              empty() const { return c.empty(); }
         size_type         size() const  { return c.size(); }
         const value_type& top() const   { return c.front(); }
      };
}

从 protected 区域可以看出， priority_queue 类仅有成员 Container 对象和 Compare 比较函数。它的内部操作实际上转化为 STL heap 算法的操作，初始化、pop、push 等操作都在容器内部操作，随后调用 make_heap 算法建立或者调整堆。

1.4  bitset

定义于头文件 bitset 中：

namespace std {
       template <size_t Bits>
       class bitset;
}

只有一个 template 参数用以指定 bit 的数量。注意该参数实际上是一个不带正负号的正数，而不是一个类型。

常用接口

operator []	存取某特定位置的位
test ()	返回bool，标志某特定位置的位
all	检查是否 all、any、none的位被设置为 true
any
none
count	返回被设置为 true 的位的个数
size	返回该 bitset 所能容纳的位数
set	设置某位为 true
reset	设置某位为 false
flip	设置某位为 !bit ，对该位值取非
to_string ()	转换为 string
to_ulong ()	转换为 unsigned long
to_ullong ()	转换为 unsigned long long

#include <iostream>
#include <bitset>
#include <limits>
#include <map>

enum Color { red, yellow, green, blue, white, black,
    numColors };

int main() {
    using namespace std;

    map<Color, string> mp;
    mp[red] = "red";
    mp[yellow] = "yellow";
    mp[green] = "green";
    mp[blue] = "blue";
    mp[white] = "white";
    mp[black] = "black";

    // create bitsetfor all bits/colors
    bitset<numColors> usedColors;
    //bitset<numColors> usedColors;使用该语句效果一样，因为枚举类型 numColors 对应的值为6

    // set bits for two colors
    usedColors.set(red);
    usedColors.set(blue);

    // 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]) {
                    cout << "color: " << mp[(Color)c] << " was used!" << endl;  //此处 mp[key] 中的key必须转换为Color枚举类型，而不能期望自动转换
            }
        }
    }

    usedColors[red] = false;
    cout << "change red to unused: " << usedColors.test(red) << endl;
    usedColors.flip(red);
    cout << "change red to used: " << usedColors.test(red) << endl;
    usedColors.reset(red);
    cout << "change red to unused: " << usedColors.test(red) << endl;

    bitset<numeric_limits<unsigned short >::digits> bits(128);

    cout << "use numeric_limits<T>::digits : " << bits << endl;
    //cout << bitset<numeric_limits<unsigned short>::digits>(128) << endl;两者效果等同
    string s = bits.to_string();  //必须使用成员函数 to_string 而不是 std::to_string()

    cout << "bits to string: " << s << endl;

    unsigned long exchanged_val = bitset<64>(s).to_ulong();
    unsigned long val = bits.to_ulong();
    cout <<  "bitset to long: " << val << endl;
    cout << "string to bitset to unsigned long:" << exchanged_val <<endl;

    return 0;
}

输出结果：

bitfield of used colors: 001001
number of used colors: 2
bitfield of unused colors: 110110
color: red was used!
color: blue was used!
change red to unused: 0
change red to used: 1
change red to unused: 0
use numeric_limits<T>::digits : 0000000010000000
bits to string: 0000000010000000
bitset to long: 128
string to bitset to unsigned long:128

用 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

操作符 << 针对bitset 的特别设计，允许将一个 bitset 打印为一个二进制串。如果需要存储为字符串，需要使用 bitset 提供的成员函数 to_string ()，如：

string s = bitset<32>(1234567).to_string();

同样，也可以把字符串转换为一个 bitset：

bitset<64>("10010010");

然后调用 bitset 的成员函数 to_ullong ()，使字符串转换为一个整数值：

bitset<64>("10010010").to_ullong();