注意事項 ：

• 實際使用的時候，使用的是<algorithm>這個頭文件，不是題目中的< stl_algobase.h >?

equal函數

• 如果兩個序列在［firsLlast） 區間內相等，equal()?返 回 true.如果第二序列的元素比較多，多出來的元素不予考慮。因此，如果我們希望保證兩個序列完全相等，必須先判斷其元素個數是否相同

int ia[9] = {0,1,2,3,4,5,6,7,8};std::vector<int> iv1(ia,ia+5);std::vector<int> iv2(ia,ia+9);if(iv1.size() == iv2.size() &&std::equal(iv1.begin(),iv1.end(),iv2.begin())){}

• 抑或使用容器所提供的equality操作符，例如 vecl = =vec2.如果第二序列的 元素比第一序列少，這個算法內部進行迭代行為時，會超越序列的尾端，造成不可預測的結果
• 第一版本缺省采用元素型別所提供的equality操作符來進行大小比 較，第二版本允許我們指定仿函數pred作為比較依據

?fill

• 將 [first/ last) 內的所有元素改填新值.?

int ia[9] = {0,1,2,3,4,5,6,7,8};std::vector<int> iv1(ia,ia+5);std::vector<int> iv2(ia,ia+9);std::fill(iv2.begin(),iv2.end(),-1);for (auto elem:iv2) {std::cout<< elem << ' ';}std::cout<< "\n";

?fill_n

• 將[firsllast)內的前n 個元素改填新值，返回的迭代器指向被填入的最后一個元素的下一位置。

• ?如果n 超越了容器的現有大小，會造成什么結果？例如

• ?我們很容易就可以從源代碼知道，由于每次迭代進行的是assignment操作，是一種覆寫(overwrite)操作，所以一旦操作區間超越了容器 大小，就會造成不可預期的結果。解決辦法之一是，利用inserter ()產生一個具 有插入(insert)而非覆寫(overwrite)能力的迭代器。
• inserter( ) 可產生一個用來修飾迭代器的配接器(iterator adapter)。用法如下

int main(int argc,char* argv[]) {int ia[9] = {0,1,2};std::vector<int> iv1(ia,ia+3);std::fill(iv1.begin(),iv1.end(),-1);std::fill_n(iv1.begin(),5,7);for (auto elem:iv1) {std::cout<< elem << ' ';}std::cout<< "\n"; }

• ?但是實際使用的時候 并沒有出現問題

?iter_swap

• ?iter_swap( ) 是 “迭代器之valuetype派上用場的一個好例子。是的，該函數 必須知道迭代器的veluetype,才能夠據此聲明一個對象，用來暫時存放迭代器所 指對象。為此，上述源代碼特別設計了一個雙層構造，第一層調用第二層，并多出一個額外的參數value_type(a) 這么一來，第二層就有VClIue type可以用了。
• 乍見之下你可能會對這個額外參數在調用端和接受端的型別感到訝異，調用端是value_type (a), 接受端卻是T*。只要找出value_type ()的定義瞧瞧，就一點也不奇怪了：

#include <iostream> #include <algorithm> #include <vector> #include <random> #include <functional>template<class ForwardIt> void selection_sort(ForwardIt begin,ForwardIt end){for (ForwardIt i = begin;i!=end;++i) {std::iter_swap(i,std::min_element(i,end));} } int main(int argc,char* argv[]) {std::random_device rd{};std::mt19937 gen(rd());std::uniform_int_distribution<>dist(-9,9);std::vector<int>v{};std::generate_n(std::back_inserter(v),20,std::bind(dist,gen));std::cout << "Before sort:" << std::showbase;for (auto e:v) {std::cout<<e<<' ';}selection_sort(v.begin(),v.end());std::cout<<"\nAfter sort:";for (auto e:v) {std::cout << e << ' ';}}

lexicographic al_.com pare

• 以 “字典排列方式”對兩個序列［firstlAastl)和 ［first2,last2)itt行比較。比較操作針對兩序列中的對應位置上的元素進行，并持續直到(1 )某一組對應元素彼此不相等；(2 )同時到達last1?和 last2 (當兩序列的大小相同)；⑶ 到 達 lastl或last2 (當 兩 序 列 的 大 小 不 同 )。
• 第一序列以字典排列方式(lexicographically)而言不小于第二序列

• ?第二版本允許你指定一個仿函數comp作為比較操作之用，取代元素型別所提 供 的 less-than (小 于 )操 作 符?

#include <iostream> #include <algorithm> #include <vector> #include <random>int main(int argc,char* argv[]) {std::vector<char>v1{'a','b','c','d'};std::vector<char>v2{'a','b','c','d'};std::mt19937 g{std::random_device{}()};while (!std::lexicographical_compare(v1.begin(),v1.end(),v2.begin(),v2.end())){for (auto c:v1) std::cout << c << ' ';std::cout << ">= ";for (auto c:v2) std::cout << c << ' ';std::cout << "\n";std::shuffle(v1.begin(),v1.end(),g);std::shuffle(v2.begin(),v2.end(),g);}for (auto c:v1) std::cout << c << ' ';std::cout << "< ";for (auto c:v2) std::cout << c << ' ';std::cout << "\n"; }

mism atch

• 用來平行比較兩個序列，指出兩者之間的第一個不匹配點。返回一對迭代器；分別指向兩序列中的不匹配點，如下圖。
• 如果兩序列的所有對應元素都匹配，返回的便是兩序列各自的last迭代器。
• 缺省情況下是以equality操作符來比較元素； 但第二版本允許用戶指定比較操作。如果第二序列的元素個數比第一序列多，多出來的元素忽略不計。如果第二序列的元素個數比第一序列少，會發生未可預期的行為。

#include <iostream> #include <algorithm> #include <vector> #include <random>bool mypredicate(int i,int j){return (i==j); }int main(int argc,char* argv[]) {std::vector<int>my_vector{};for (int i = 1; i < 6; ++i) {my_vector.emplace_back(i*10);//10 20 30 40 50 }int myints[] = {10,20,80,320,1024};std::pair<std::vector<int>::iterator,int*>mypair;mypair = std::mismatch(my_vector.begin(),my_vector.end(),myints);std::cout << "First mismatching elements: " << *mypair.first;std::cout << " and " << *mypair.second << std::endl;++mypair.first;++mypair.second;mypair = std::mismatch(mypair.first,my_vector.end(),mypair.second, mypredicate);std::cout << "Second mismatching elements: " << *mypair.first;std::cout << " and " << *mypair.second << std::endl;return 0; }

copy----- 強化效率無所不用其極

• 不論是對客端程序或對STL內部而言， copy() 都是一個常常被調用的函數。由 于 copy進行的是復制操作，而復制操作不外乎運用assignment operator或 copy constructor (copy算法用的是前者)，但是某些元素型別擁有的是trivial assignment operator, 因此，如果能夠使用內存直接復制行為(例如C 標準函數memmove或 memcpy) , 便能夠節省大量時間。為此，SGI STL的 copy 算法用盡各種辦法，包括函數重載(function overloading) 、型別特性(type traits)、偏特 化 (partial specialization) 等編程技巧，無所不用其極地加強效率。圖 6-2表ZK整個copy() 操作的脈絡。配合稍后出現的源代碼，可收一目了然之效。

• ?copy算法可將輸入區間［first, last)內的兀素復制到輸出區間［result, result+(last-first)) 內? 也就是說，它會執行賦值操作 *result = *first, * (result + 1) = * ( f irst + 1) , … 依 此 類 推 。 返 回 一 個 迭 代 器 ： result+(last-first)= copy 對其template參數所要求的條件非常寬松。其輸入區間只需由Inputiterators構成即可，輸出區間只需由Outputiterator構成即可。
• 這意味著你可以使用copy算法，將任何容器的任何一段區間的內容，復制到任何 容器的任何一段區間上

• ?如果輸入區間和輸出區間完全沒有重疊，當然毫無問題，否則便需特別注意?為什么圖6-3第二種情況(可能)會產生錯誤？從稍后即將顯示的源代碼可知，copy 算法是一一進行元素的賦值操作，如果輸出區間的起點位于輸入區間內，copy算法便(可能)會在輸入區間的(某些)元素尚未被復制之前，就覆蓋其值，導致錯誤結果.在這里我一再使用“可能”這個字眼，是因為，如果copy算法根據其所 接收的迭代器的特性決定調用 memmove() 來執行任務，就不會造成上述錯誤，因 為 memmove() 會先將整個輸人區間的內容復制下來，沒有被覆蓋的危險。

int ia[] = {0,1,2,3,4,5,6,7,8};//輸出區間的終點和輸入的區間重疊 沒有問題std::copy(ia+2,ia+7,ia);std::for_each(ia,ia+9,display<int>());std::cout << "\n"; // 以下，輸出區間的起點與輸入區間重疊，可能會有問題int ia[] = {0,1,2,3,4,5,6,7,8};std::copy(ia+2,ia+7,ia+4);std::for_each(ia,ia+9,display<int>());std::cout << "\n"; //0 1 2 3 2 3 4 5 6 int ia[] = {0,1,2,3,4,5,6,7,8};//deque 擁有 RandomAcCGSSltGrCltorstd::deque<int>id(ia,ia+9);std::deque<int>::iterator first = id.begin();std::deque<int>::iterator last = id.end();++++first; //advance(first,2);std::cout << *first << std::endl; //2----last; //advance(last,-2);std::cout << *last << std::endl; //7std::deque<int>::iterator result = std::begin(id);std::cout << * result << std::endl;// 以下，輸出區間的終點與輸入區間重疊，沒問題std::copy(first,last,result);//(2 3 4 5 6) 5 6 7 8std::for_each(id.begin(),id.end(),display<int>{});std::cout << "\n";return 0; int ia[] = {0,1,2,3,4,5,6,7,8};//deque 擁有 RandomAcCGSSltGrCltorstd::deque<int>id(ia,ia+9);std::deque<int>::iterator first = id.begin();std::deque<int>::iterator last = id.end();++++first; //advance(first,2);std::cout << *first << std::endl; //2----last; //advance(last,-2);std::cout << *last << std::endl; //7std::deque<int>::iterator result = std::begin(id);std::advance(result,4);std::cout << * result << std::endl;//以下，輸出區間的起點與輸入區間重疊，可能會有問題//本例結果錯誤，因為調用的 copy算法不再使用memmove ()執行實際復制操作std::copy(first,last,result);//0 1 2 3 (2 3 4 5 6std::for_each(id.begin(),id.end(),display<int>{});std::cout << "\n";return 0;

• 請注意，如果你以vector取代上述的deque進行測試，復制結果將是正確的，因 為 vector迭代器其實是個原生指針(native pointer), 見4.2.3節，導致調用的copy算法以memmove ()執行實際復制操作
• copy更改的是［result,result + (last-first)) 中的迭代器所指對象，而非更改迭代器本身。它會為輸出區間內的元素賦予新值，而不是產生新的元素。它不能改變輸出區間的迭代器個數。換句話說 , copy不能直接用來將元素插入空容器中。例子如下所示：如果不給myvector申請空間就會出錯，只有申請空間之后初始化為0，然后執行覆蓋原有數值的操作
• 如果你想要將元素插入(而非賦值)序列之內，要么明白使用序列容器的insert 成員函數，要么使用 copy 算法并搭配 insert_iterator (8.3.1 節 )
• 現在我們來看看 copy算法龐大的實現細節。下面是冰山一角，也是唯一的對外接口：

int main(int argc,char* argv[]) {int myints[]={10,20,30,40,50,60,70};std::vector<int>myvector(7);std::copy(myints,myints+7,myvector.begin());std::cout << "myvector contains:";for (std::vector<int>::iterator it = myvector.begin();it != myvector.end();++it) {std::cout << ' '<< *it;}std::cout << "\n";return 0; }

• ?下面兩個是多載函數，針對原生指針(可視為一種特殊的迭代器)const char*和 const wchar_t*, 進行內存直接拷貝操作：

• ?這里必須兵分兩路來探討。首先，_ copy_dispatch ()的完全泛化版根據迭代器種類的不同，調用了不同的 一copy()> 為的是不同種類的迭代器所使用的循 環條件不同，有快慢之別.

• 這 是 __copy_dispatch ()完全泛化版的故事。現在回到前述兵分兩路之處， 看看它的兩個偏特化版本。這兩個偏特化版是在“參數為原生指針形式”的前提下，希望進一步探測“指針所指之物是否具有trivial assignment operator (平凡 賦值操作符)” ? 這一點對效率的影響不小，因為這里的復制操作是由assignment 操作符負責，如果指針所指對象擁有non-trivial assignment operator,復制操作就 一定得通過它來進行。但如果指針所指對象擁有的是trivial assignment operator, 復制操作可以不通過它，直接以最快速的內存對拷方式(memmove ())完成。C++語言本身無法讓你偵測某個對象的型別是否具有trivial assignment operator,但是SGI STL采用所謂的 ?type_traits<> 編程技巧來彌補(見3.7節)。注意，通 過 “增 加一層間接性”的手法，我們便得以區分兩個不同的 ?copy_t():

• 第三個問題的解答是：我們以為vector的迭代器是random access iterator,沒想到它事實上是個T*?；vector迭代器其實是原生指針。這就怪不得copy。?一旦面對vector 迭代器，就往T*的方向走去了；

?6.4.4 copy_backw ard

• 將［firstaast)區間內的每一個元素，以逆行的方向復制到 以 result-1為起點，方向亦為逆行的區間上。換句話說，copy_backward算法會
  執行賦值操作 * (result-1) =?* (last-1) , * (result-2 ) = * (last-2 ) , 依此類推。
• 返回一個迭代器：result- (last-first) □ copy_backward所接受的迭代器必
  須 是 Bidirectionallterators, 才 能 夠 “倒行逆施”。你可以使用copy_backward算
  法，將任何容器的任何一段區間的內容，復制到任何容器的任何一段區間上°如果輸
  入區間和輸出區間完全沒有重疊，當然毫無問題，否則便需特別注意

?

int ia[] = {0,1,2,3,4,5,6,7,8};//輸出區間的終點和輸入區間重疊 沒問題std::copy_backward(ia+2,ia+7,ia+9);std::for_each(ia,ia+9,display<int>{});//0 1 2 3 2 3 4 5 6std::cout<<std::endl;return 0; int ia[] = {0,1,2,3,4,5,6,7,8};//輸出區間的起點和輸入區間重疊 可能會有問題std::copy_backward(ia+2,ia+7,ia+5);std::for_each(ia,ia+9,display<int>{});//2 3 4 5 6 5 6 7 8//本例結果正確，因為調用的copy算法使用memmove ()執行實際復制操作std::cout<<std::endl;return 0;

?

template<class T> struct display{void operator()(const T&x){std::cout << x << ' ';} }; int main(int argc,char* argv[]) {int ia[] = {0,1,2,3,4,5,6,7,8};std::deque<int>id(ia,ia+9);std::deque<int>::iterator first = id.begin();std::deque<int>::iterator last = id.end();++++first; //advance(first,2);std::cout << *first << std::endl;----last; //advance(last,-2);std::cout << *last << std::endl;std::deque<int>::iterator result = id.end();//輸出區間的終點和輸入區間重疊 沒有問題std::copy_backward(first,last,result);std::for_each(id.begin(),id.end(),display<int>{});//0 1 2 3 2 3 4 5 6std::cout<<std::endl;return 0; } int main(int argc,char* argv[]) {int ia[] = {0,1,2,3,4,5,6,7,8};std::deque<int>id(ia,ia+9);std::deque<int>::iterator first = id.begin();std::deque<int>::iterator last = id.end();++++first; //advance(first,2);std::cout << *first << std::endl;----last; //advance(last,-2);std::cout << *last << std::endl;std::deque<int>::iterator result = id.begin();std::advance(result,5);std::cout << *result << std::endl;//輸出區間的起點和輸入區間重疊 可能會有問題std::copy_backward(first,last,result);// 本例結果錯誤，因為調用的copy算法不再使用memmove()執行實際復制操作 但是我實際編碼結果是正確的std::for_each(id.begin(),id.end(),display<int>{});//2 3 4 5 6 5 6 7 8std::cout<<std::endl;return 0; }

總結

以上是生活随笔為你收集整理的STL源码剖析 基本算法 ＜ stl_algobase.h ＞的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。