#include <iostream>
#include <vector>
#include <algorithm>
#include <string>

using namespace std;

int main(void)
{

    system("pause");
    return 0;
}

void test01()
{
    vector<int> v;
    //每一個容器都有自己的迭代器，迭代器是用來遍歷容器中的元素
	//v.begin()返回迭代器，這個迭代器指向容器中第一個資料
	//v.end()返回迭代器，這個迭代器指向容器元素的最後一個元素的下一個位置
	//vector<int>::iterator 拿到vector<int>這種容器的迭代器型別

    /* vector構造賦值

        vector<T> v;    //預設構造
        vector(v.begin(), v.end()); //將v[begin(), end()]中的元素拷貝本身
        vector(n, elem);    //建構函式將n個elem拷貝給本身
        vector(const ventor &vec);  //拷貝建構函式

        vector& operator=(const vector &vec);   //過載等號操作符
        assign(beg, end);   //將[beg, end]區間中的資料拷貝賦值給本身
        assign(n, elem);    //將n個elem拷貝賦值給本身
    */

    /* ventor容量和大小

        empty();    //判斷是否為空
        capacity(); //容器的容量
        size();     //元素個數
        resize(int num);   //重新指定容器長度為num, 若容器變長，以預設值指定新位置
        resize(int num, elem)   //重新指定，若變長，則以elem填充位置，變短則刪除多餘
    */

    /* vector插入刪除

        push_back(ele);     //尾部插入元素ele
        pop_back();     //刪除最後一個
        insert(const_iterator pos, ele);    //迭代器指向位置pos插入元素ele
        insert(const_iterator pos, int count, ele)  //迭代器指向位置pos插入count個ele
        erase(const_iterator pos);  //刪除迭代器指向的元素
        erase(const_iterator start, const_iterator end);    //刪除迭代器從start到end的元素
        clear();    //刪除容器中的所有元素
    */

    /* vector資料存取

        at(int idx);    //返回索引idx所指的資料
        operator[];     //返回[]處的資料
        front();    //返回容器中第一個資料元素
        back();     //返回容器中最後一個數據元素
    */

    /* vector互換容器和預留空間
    
        swap(vec);  //將vec與本身的元素互換
        reserve(int len);   //容器預留len個元素長度，預留位置不初始化，元素不可訪問
    */
    v.push_back(1);
    v.push_back(2);
}

void test02()
{
    // 字串大小用size()

    /* 字串建立操作 

        string()    //建立一個空字串
        string(const char* s)    //使用字串s初始化
        string(const string& str)   //使用string物件初始化另一個string
        string(int n, char c)   //使用n個字元c初始化
    */

   /* 字串賦值操作

        string& operator = (const char *s);    //char*型別字串賦值給當前的字串
        string& operator = (const string &s);  //把字串s賦值給當前字串
        string& operator = (char c);    //把字元c賦值給當前字串
        string& assign(const char *s);  //把字串s賦給當前字串。
        string& assign(const char *s, int n);    //把字串s的前n個字元賦值給當前字串
        string& assign(const string &s);    //把當前字串s賦給當前字串
        string& assign(int n, char c);    //把n個字元賦值給當前字元
   */

    /* 字串拼接

            string& operator += (const char * str);   //過載+=操作符
            string& operator += (const char c);       //過載+=操作符
            string& operator += (const string &str);  //過載+=操作符
            string& append(const char *s);  //把字串連線到當前字串結尾
            string& append(const char *s, int n)    //把字串s的前n個字元連線到當前字串結尾
            string& append(const string &s)     //把字串s連線到末尾
            string& append(const string &s, int pos, int n);    //字串s中從pos開始的n個字串連線到字串末尾    
    */

    /* 字串查詢替換

        * find查詢是從左往後，rfind從右往左
        * find找到字串後返回查詢的第一個字元位置，找不到返回-1
        * replace在替換時，要指定從哪個位置起，多少個字元，替換成什麼樣的字串

        int find(const string &str, int pos = 0);  //查詢str第一次出現的位置，從pos開始
        int find(const char* s, int pos = 0);   //查詢s第一次出現的位置，從pos開始
        int find(const char* s, int pos = 0, int n);    //從pos開始查詢s的前n個字元第一次位置
        int find(const char c, int pos = 0);    //查詢字元c第一次出現的位置
        int rfind(const string& str, int pos = npos) const;  //查詢str最後一次出現的位置，從pos開始找
        int rfind(const char* s, int pos = npos) const;  //查詢s最後一次出現的位置，從pos開始
        int rfind(const char* s, int pos, int n) const;  //從pos查詢s的前n個字元最後一次位置
        int rfind(const char c, int pos = 0) const;    //查詢字元c最後一次出現的位置

        string& replace(int pos, int n, const string &str);   //替換從pos開始n個字元為字串str
        string& replace(int pos, int n, const char *s)    //替換從pos開始的n個字元為字串s
    */

   /* 字串比較存取
        按照字元的ascii碼進行對比，=返回0，>返回1，小於返回-1
        int compare(const string &s) const;  //與字串s比較
        int compare(const char *s) const;   //與字串s比較

        char& operator[](int n);  //通過[]取字元
        char& at(int n);    //通過at()方法去字元
   */

    /* 字串插入刪除

        string& insert(int pos, const char* s);  //插入字串
        string& insert(int pos, const string& str); //插入字串
        string& insert(int pos, int n, char c);  //在指定位置插入n個字元c
        string& erase(int pos, int n = npos);   //刪除從Pos開始的n個字元
    */

    /* string子串

        string substr(int pos = 0, int n = npos) const; //返回由pos開始的n個字元組成的字串
    */
    string s1;
}

void test03()
{
    /* deque與vector的區別：

        vector對於頭部的插入刪除效率低，資料量越大，效率越低
        deque相對而言，對頭部的插入刪除速度回比vector快
        vector訪問元素時的速度會比deque快,這和兩者內部實現有關
    */

    /* deque內部工作原理：

        deque內部有個中控器，維護每段緩衝區中的內容，緩衝區中存放真實資料
        中控器維護的是每個緩衝區的地址，使得使用deque時像一片連續的記憶體空間
        deque容器的迭代器也是支援隨機訪問的
    */

    /* 構造和賦值和vector一樣
        deque沒有容量的概念，其餘和vector一樣
    */

    /* 插入刪除
        比vector多了push_front(), pop_front();
    */
    
    /* 資料存取和vector一樣
    */

    /* deque排序---包含標頭檔案<algorithm>

        sort(iterator beg, iterator end);   //對beg和end取鍵元素排序
    */
}

void test04()
{
    /* stack 容器

        建構函式:
            stack<T> stk;   //stack採用模板實現，stack物件預設構造型別
            stack(const stack &stk);    //拷貝建構函式
        賦值操作：
            stack& operator=(const stack &stk)  //過載等號操作符
        資料存取：
            push(elem); //向棧頂壓入元素
            pop();  //從棧頂取出元素
            top();  //返回棧頂元素
        大小操作：
            empty();    //判斷堆疊是否為空
            size();     //返回棧的大小

            
    */
}

void test05()
{
    /* queue容器

        建構函式：
            queue<T> que;   //queue採用模板類實現，預設構造
            queue(const queue &que);    //拷貝構造
        賦值操作：
            queue& operator=(const queue &que); //過載等號
        資料存取：
            push(elem);     //往隊尾新增元素
            pop();          //從隊頭移除第一個元素
            back();         //返回最後一個元素
            front();        //返回第一個元素
        大小操作：
            empty();        //判斷堆疊是否為空
            size();         //返回大小
    */
}

void test06()
{
    /* list容器，鏈式儲存
    
    */
}