#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<int>::const_iterator
/* list容器，鏈式存盤，構造
list<T> lst; //默認構造
list(beg, end); //建構式將[beg,end]中的元素拷貝
list(n, elem); //將n個elem拷貝本身
list(const list &lst); //拷貝建構式
*/
/* 賦值交換
assign(beg, end); //將[beg,end)之間的資料拷貝
assign(n, elem); //將n個elem賦值
list& operator=(const list &lst); //多載=
swap(lst); //將lst于本身元素互換
*/
/* 大小操作
size(); //回傳元素個數
empty(); //判斷是否空
resize(num); //重新指定長度為num
resize(num, elem); //多了以elem補全
*/
/* 插入洗掉
push_back(elem); //在尾部加入一個元素
pop_back(); //洗掉尾部最后一個元素
push_front(); //在容器開頭插入一個元素
pop_front(); //在容器開頭移除一個元素
insert(pos, elem); //在pos位置插elem元素的拷貝，回傳新資料的位置
insert(pos, n, elem); //在pos位置插入n個elem資料，無回傳值
insert(pos, beg, end); //在pos位置插入[beg, end]區間的資料，無回傳值
clear(); //移除容器中所有資料
erase(beg, end);
erase(pos);
remove(elem); //洗掉容器中所有與elem值匹配的元素
*/
/* 資料存取
front(); //回傳第一個元素
back(); //回傳最后一個元素
*/
/* list反轉與排序
reverse(); //反轉鏈表
sort(); //鏈表排序
*/
}
void test07()
{
/* set/multiset容器
簡介：所有元素都會在插入時自動被排序
關聯式容器，二叉樹實作
set和multiset區別：
set不允許容器中有重復的元素
multiset允許容器中有重復的元素
set插入資料的同時會回傳插入結果，表示插入是否成功
multiset不會檢測資料，因此可以插入重復資料
*/
/* set構造賦值
set<T> st; //默認建構式
set(const set &set); //拷貝建構式
set& operator = (const set &st); //多載=
*/
/*
set容器插入資料時用insert
set容器插入資料時自動排序
size(); //回傳元素數目
empty(); //判斷容器是否為空
swap(); //交換兩個集合容器
*/
/* set插入洗掉 查找統計
insert(elem); //插入元素
clear(); //清楚所有元素
erase(pos); //洗掉pos迭代器位置的元素，回傳下一個迭代器位置
erase(beg, end) //洗掉區間元素，回傳下一個元素迭代器
erase(elem) //洗掉容器中值為elem的元素
find(key); //查找是否存在，回傳迭代器，不存在回傳set.end();
count(key); //統計key的元素個數
*/
}
void test08()
{
/* pair對組創建
功能描述：成對出現的資料，利用對組可以回傳兩個資料
*/
/* 創建方式
pair<type, type> p (value1, value2);
pair<type, type> p = make_pair(value1, value2);
p.first //第一個元素
p.second //第二個元素
*/
}
void test09()
{
/* map/ multimap容器
map中所有元素都是成對出現，插入資料時候要使用對組
簡介：
map中所有元素都是pair
pair中第一個元素為key（鍵值），起到索引作用，第二個元素為value（實值）
所有元素都會根據元素的鍵值自動排序
map/multimap屬于**關聯式容器**，底層結構是用二叉樹實作，
優點：
可以根據key值快速找到value值
map和multimap的區別：
map不允許容器中有重復key值元素
multimap允許容器中有重復key值元素
*/
/* map的構造賦值
map<T1, T2> mp;
map(const map &map);
map& operator = (const map &map);
*/
/* map的大小和交換
size(); //回傳元素數目
empty(); //判空
swap(st); //交換兩個集合容器
*/
/* 插入洗掉
insert(elem); //插入元素
clear(); //清除所有元素
erase(pos); //洗掉pos所指的元素，回傳下一個迭代器
erase(beg, end);
erase(key); //洗掉容器中值為key的元素
*/
/* 查找統計
find(key); //查找key是否存在，回傳該鍵元素的迭代器，不存在，回傳set.end()
count(key); //統計key的元素的個數
*/
}
void test10()
{
/* 常用遍歷演算法
for_each() //遍歷容器
transform() //搬運容器到另一個容器中
transform(iterator beg1, iterator end1, iterator beg2, _func);
*/
/* merge合并容器
merge(iterator beg1, iterator end1, iterator beg2, iterator end2, iterator dest);
*/
/* reverse將容器中的元素反轉
reverse(iterator beg, iterator end);
*/
/* 拷貝
copy(iterator beg, iterator end, iterator dest);
*/
}
轉載請註明出處，本文鏈接：https://www.uj5u.com/qita/201755.html
標籤：其他