vector容器型別

   vector容器是一個模板類，可以存放任何型別的物件（但必須是同一類物件）。vector物件可以在執行時高效地新增元素，並且vector中元素是連續儲存的。

   與對string類物件的介紹一樣，仍然使用簡化原型（主要是拋棄了分配器模板引數，使用預設的）。

vector的構造

函式原型：

template<typename T>
   explicit vector();                                 // 預設建構函式，vector物件為空
   explicit vector(size_type n, const T& v = T());    // 建立有n個元素的vector物件
   vector(const vector& x);
   vector(const_iterator first, const_iterator last);

注：vector容器記憶體放的所有物件都是經過初始化的。如果沒有指定儲存物件的初始值，那麼對於內建型別將用0初始化，對於類型別將呼叫其預設建構函式進行初始化（如果有其它建構函式而沒有預設建構函式，那麼此時必須提供元素初始值才能放入容器中）。

舉例：
vector<string> v1;         // 建立空容器，其物件型別為string類
vector<string> v2(10);     // 建立有10個具有初始值（即空串）的string類物件的容器
vector<string> v3(5, "hello"); // 建立有5個值為“hello”的string類物件的容器
vector<string> v4(v3.begin(), v3.end());  // v4是與v3相同的容器（完全複製）

vector的操作（下面的函式都是成員函式）
 
bool empty() const;                    // 如果為容器為空，返回true；否則返回false
size_type max_size() const;            // 返回容器能容納的最大元素個數
size_type size() const;                // 返回容器中元素個數  
size_type capacity() const;            // 容器能夠儲存的元素個數，有：capacity() >= size()  
void reserve(size_type n);             // 確保capacity() >= n
void resize(size_type n, T x = T());   // 確保返回後，有：size() == n；如果之前size()<n，那麼用元素x的值補全。

reference front();                     // 返回容器中第一個元素的引用（容器必須非空）
const_reference front() const;                   
reference back();                      // 返回容器中最後一個元素的引用（容器必須非空）
const_reference back() const;

reference operator[](size_type pos);   // 返回下標為pos的元素的引用（下標從0開始；如果下標不正確，則屬於未定義行為。
const_reference operator[](size_type pos) const; 
reference at(size_type pos);           // 返回下標為pos的元素的引用；如果下標不正確，則丟擲異常out_of_range
const_reference at(size_type pos) const;
            
void push_back(const T& x);            // 向容器末尾新增一個元素          
void pop_back();                       // 彈出容器中最後一個元素（容器必須非空）

// 注：下面的插入和刪除操作將發生元素的移動（為了保持連續儲存的性質），所以之前的迭代器可能失效
iterator insert(iterator it, const T& x = T());        // 在插入點元素之前插入元素（或者說在插入點插入元素）
void insert(iterator it, size_type n, const T& x);     // 注意迭代器可能不再有效（可能重新分配空間）
void insert(iterator it, const_iterator first, const_iterator last);

iterator erase(iterator it);           // 刪除指定元素，並返回刪除元素後一個元素的位置（如果無元素，返回end()）
iterator erase(iterator first, iterator last); // 注意：刪除元素後，刪除點之後的元素對應的迭代器不再有效。

void clear() const;                    // 清空容器，相當於呼叫erase( begin(), end())

void assign(size_type n, const T& x = T());   // 賦值，用指定元素序列替換容器內所有元素
void assign(const_iterator first, const_iterator last);

const_iterator begin() const;          // 迭代序列
iterator begin();
const_iterator end() const;
iterator end();

const_reverse_iterator rbegin() const;
reverse_iterator rbegin();
const_reverse_iterator rend() const; 
reverse_iterator rend();

vector物件的比較（非成員函式）

   針對vector物件的比較有六個比較運算子：operator==、operator!=、operator<、operator<=、operator>、operator>=。

   其中，對於operator==和operator!=，如果vector物件擁有相同的元素個數，並且對應位置的元素全部相等，則兩個vector物件相等；否則不等。

   對於operator<、operator<=、operator>、operator>=，採用字典排序策略比較。

注：其實只需要實現operator==和operator!=就可以了，其它可以根據這兩個實現。因為，operator!=(lhs, rhs) 就是 !(lhs == rhs)，operator<=(lhs, rhs) 就是 !(rhs < lhs)，operator>(lhs, rhs) 就是 (rhs < lhs)，operator>=（lhs, rhs) 就是 !(lhs, rhs)。

vector類的迭代器

   vector類的迭代器除了支援通用的字首自增運算子外，還支援算術運算：it + n、it - n、it2 - it1。注意it2 - it1返回值為difference_type（signed型別）。

   注意，任何改變容器大小的操作都可能造成以前的迭代器失效。

應用示例

程式說明：上面程式中用了三個迴圈輸出容器中的元素，每個迴圈的遍歷方式是不一樣的。特別需要說明的是，第二個迴圈在條件判斷中使用了size()函式，而不是在迴圈之前先儲存在變數中再使用。之所以這樣做，有兩個原因：其一，如果將來在修改程式時，在迴圈中修改了容器元素個數，這個迴圈仍然能很好地工作，而如果先儲存size()函式值就不正確了；其二，由於這些小函式（其實現只需要一條返回語句）基本上都被宣告為inline，所以不需要考慮效率問題。

迭代器

   迭代器(iterator)是用來遍歷容器內所有元素的資料型別。標準庫為每一種標準容器定義了一種迭代器型別。迭代器型別提供了比下標操作更通用的方法：所有標準容器類都定義了相應的迭代器型別，而只有少數的容器支援下標操作。所以，在編寫C++程式時，用迭代器遍歷容器是一種更通用的方法，也更加安全。一般提供兩種型別：iterator和const_iterator。

begin()和end()操作

   每種容器都定義了一對命名為begin()和end()的函式，用來返回容器的迭代序列。其中，begin返回的迭代器指向第一個元素，end返回的迭代器指向最後一個元素的下一個位置（實際上是一個不存在的元素），所以迭代序列為[begin(), end())。如果容器為空，那麼begin()返回與end()一樣的迭代器。

訪問容器元素(operator*)

   假如迭代器it指向容器的一個元素，那麼解引用*it就是該元素的值（注意，不能對end()解引用）。

下一個元素(operator++)

   所有迭代器都支援字首自增運算子，如++it，表示把迭代器移到容器中的下一個元素的位（同樣不能對end()運算）。

比較 (operator == or operator !=)

   所有迭代器都支援迭代器之間的比較：
   operator ==：如果兩個迭代器指向同一元素，那麼返回true；否則返回false。(operator != 類似）

bitset模板類

template<size_t N>
    class bitset;

   bitset也是類模板，其模板引數N必須是常量表達式（能夠在編譯時計算出其值），表示bitset類物件的長度（位的個數）。bitset物件用來作為位容器，方便對位的操作，其元素為位。bitset物件元素的位置編號從 0 到 N - 1，對應著位串從低位到高位。

bitset類物件的構造

它有三個建構函式：

bitset();   

   初始化所有位都為0     
        
bitset(unsigned long val);   

   用unsigned long初始化bitset物件，初始化bitset物件為val的位模式。
       如果bitset物件的長度小於val的位數，那麼val中多餘的高位被丟棄；
       如果bitset物件的長度大於val的位數，那麼bitset物件的高位將被置為0    

explicit bitset(const string& str, size_t pos = 0, size_t n = -1);

   用string物件中從pos下標開始的n個字元來初始化bitset物件（這些字元必須是0或者1）。如果str.size() < pos，那麼將丟擲out_of_range異常。如果指定的字元序列[pos, pos + n)中有非0、1字元，那麼將丟擲invalid_argument異常。如果n > str.size() - pos，就只使用str.size() - pos位來初始化bitset物件。如果指定的字元序列中字元個數比bitset物件位數要多，則只使用前面的字元。

   初始化規則：[pos, pos + n)序列中最後一個字元對應著bitset物件的低位（第一位），而第一個字元對應著高位。（這點符合我們看待字串形式的位串的方式：左邊是高位，右邊是低位）

舉例：
bitset<16> bs1;                   // bs1有16位，並全部初始化為0

bitset<16> bs2(0xFFFF);           // bs2有16位，並全部初始化為1
bitset<32> bs3(0xFFFF);           // bs3有32位，低16位(0-15)為1，高16位(16-31)為0
bitset<8>  bs4(0xFFFF);           // bs4有8位，並全部初始化為1

string test("111110000011");
bitset<8> bs5(test);              // bs5有8位，並且只使用test串的前八個字元"11111000"來初始化，
                                  //   所以0-7位為：0001 1111（注意與源串反向）
bitset<8> bs6(test, 4, 3);        // bs6有8位，並且用"100"來初始化，所以0-7位為：0010 0000

位的測試

bool any() const;                 // 如果容器內有任意位被置為1，則返回true；否則返回false。
bool none() const;                // 如果容器內沒有位被置為1，則返回true；否則返回false。
bool test(size_t pos, bool val = true);      // 測試位置pos處的位是否為val（預設測試是否為1）
                                             // 如果pos >= size()，那麼將丟擲異常out_of_range

bool at(size_type pos) const;     // 返回指定位；如果pos無效，那麼將丟擲異常out_of_range。
reference at(size_type pos);
bool operator[](size_type pos) const;
reference operator(size_type pos);

static const size_t bitset_size = N; //容器內的位個數N
size_t size() const;              // 返回容器內的位個數N
size_t count() const;             // 返回被置為1的位的個數

bitset<N>& flip();                // 將容器內所有位全部取反
bitset<N> operator~();            // 返回this->flip();
bitset<N>& flip(size_t pos);      // 將位置pos處的位取反；如果pos >= size()，那麼將丟擲異常out_of_range。

bitset<N>& reset();               // 將容器內所有位重置為0
bitset<N>& reset(size_t pos);     // 將位置pos處的位置為0；如果pos >= size()，那麼將丟擲異常out_of_range
bitset<N>& set();                 // 將容器內所有位重置為1
bitset<N>& set(size_t pos, bool val = true); // 將位置pos處的位置為val（預設為1)；
                                             // 如果pos >= size()，那麼將丟擲異常out_of_range

unsigned long to_ulong() const;   // 返回對應的unsigned long值；如果溢位，則丟擲overflow_error
string to_string() const;         // 把bitset物件轉換成string物件，其規則是：字串的第一字元對應容器中最後一位。
         
bool operator ==(const bitset<N>& rhs) const;   // 如果兩容器的位序列完全相等，則返回true；否則返回false.
bool operator !=(const bitset<N>& rhs) const;   // 如果兩容器的位序列不完全相等，則返回true；否則返回false。

bitset<N>& operator&=(const bitset<N>& rhs);    // 位串進行“與”運算
bitset<N>& operator|=(const bitset<N>& rhs);    // “或”運算
bitset<N>& operator^=(const bitset<N>& rhs);

bitset<N>& operator<<=(size_t pos);          // 邏輯左移pos位（向高位方向移動）
bitset<N>& operator>>=(size_t pos);          // 邏輯右移pos位（向低位方向移動）
bitset<N> operator<<(size_t pos) const;      // 返回 bitset<N>(*this) <<= pos.
bitset<N> operator>>(size_t pos) const;      // 返回 bitset<N>(*this) >>= pos.

非成員函式
ostream& operator<<(ostream& os, const bitset<N>& x);
   相當於呼叫return os<<x.to_string();
istream& operator>>(istream& is, bitset<N>& x);
   相當於呼叫: string str; is>>str; x = bitset<N>(str); return is;
      其中，當從輸入流is提取的字元個數已經有N個時，提取結束；當遇到檔案尾時，提取結束；當is中當前字元不是0也不是1時，提取結束。
   如果沒有提取到任何字元就結束了（此時x不變），那麼將呼叫is.setstate(ios_base::failbit)。

bitset<N> operator&(const bitset<N>& lhs, const bitset<N>& rhs);    // 返回 bitset<N>(lhs) &= rhs.
bitset<N> operator|(const bitset<N>& lhs, const bitset<N>& rhs);    // 返回 bitset<N>(lhs) |= rhs.
bitset<N> operator^(const bitset<N>& lhs, const bitset<N>& rhs);    // 返回 bitset<N>(lhs) ^= rhs.

另外， bitset中的reference定義如下：
class reference {
public:
    reference& operator=(bool b};
    reference& operator=(const reference& x);
    bool operator~() const;
    operator bool() const;
    reference& flip();
};

其使用舉例如下：
bitset<8> bs(string("111110000011"));
bs[2] = 0;           // 此時bs[0]-bs[7]為00011011 
bool b = ~x[2];      // b == 1, bs不變
x[2].flip();         // bs改變：bs[0]-bs[7]為00011111

應用示例