若要檢視英文版的文章,請選取 [原文] 核取方塊。您也可以將滑鼠指標移到文字上,即可在快顯視窗顯示英文原文。
譯文
原文
建議使用 Visual Studio 2017

mismatch

 

逐一比較兩個範圍的每個項目,找出差異發生的第一個位置。

使用 C++14 程式碼中的雙重範圍多載,因為如果第二個範圍超過第一個範圍,只為第二個範圍採用單一迭代器的多載不會偵測到差異;而如果第二個範圍比第一個範圍短,則會導致未定義的行為。


        template<class InputIterator1, class InputIterator2>
   pair<InputIterator1, InputIterator2> mismatch(
      InputIterator1 First1,
      InputIterator1 Last1,
      InputIterator2 First2
  );
template<class InputIterator1, class InputIterator2, class BinaryPredicate>
   pair<InputIterator1, InputIterator2> mismatch(
      InputIterator1 First1,
      InputIterator1 Last1,
      InputIterator2 First2,
      BinaryPredicate Comp
   );

//C++14
template<class InputIterator1, class InputIterator2>
   pair<InputIterator1, InputIterator2> mismatch(
      InputIterator1 First1,
      InputIterator1 Last1,
      InputIterator2 First2,
      InputIterator2 Last2
  );
template<class InputIterator1, class InputIterator2, class BinaryPredicate>
   pair<InputIterator1, InputIterator2> mismatch(
      InputIterator1 First1,
      InputIterator1 Last1,
      InputIterator2 First2,
      InputIterator2 Last2,
      BinaryPredicate Comp
   );

First1

輸入迭代器,定址要測試的第一個範圍中第一個項目的位置。

Last1

輸入迭代器,定址要測試的第一個範圍中最後一個項目的後面一個位置。

First2

輸入迭代器,定址要測試的第二個範圍中第一個項目的位置。

Last2

輸入迭代器,定址要測試的第二個範圍中最後一個項目的後面一個位置。

Comp

使用者定義述詞函式物件,比較每個範圍中的目前項目,並判斷是否相等。  相等時傳回 true ,不相等則傳回 false  

一組迭代器,定址兩個範圍中不相符的位置,第一個元件迭代器指向第一個範圍中的位置,而第二個元件迭代器指向第二個範圍中的位置。  如果比較的範圍中的項目之間沒有差異,或第二個版本中的二元述詞由兩個範圍的所有項目配對所滿足,則第一個元件迭代器會指向第一個範圍中最後一個項目的後面一個位置,而第二個元件迭代器會指向第二個範圍中測試的最後一個項目的後面一個位置。  

第一個樣板函式會假設範圍中從 first2 開始的項目數,與 [first1, last1) 指定的範圍中的項目數相同。  如果第二個範圍中的項目較多,則會忽略它們;如果較少,則會導致未定義的行為。  

要搜尋的範圍必須有效;所有迭代器都必須可以取值,而且可透過遞增從第一個位置到達最後一個位置。

在較短範圍內包含的項目數中,演算法的時間複雜性呈線性。

使用者定義的述詞不需要在運算元之間強加對稱、自反和遞移的等價關係。

範例

下列範例示範如何使用不相符。  顯示 C++03 多載只是為了示範可能產生非預期的結果。  


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

using namespace std;

// Return whether first element is twice the second
// Note that this is not a symmetric, reflexive and transitive equivalence.
// mismatch and equal accept such predicates, but is_permutation does not.
bool twice(int elem1, int elem2)
{
    return elem1 == elem2 * 2;
}

void PrintResult(const string& msg, const pair<vector<int>::iterator, vector<int>::iterator>& result,
    const vector<int>& left, const vector<int>& right)
{
    // If either iterator stops before reaching the end of its container,
    // it means a mismatch was detected.
    if (result.first != left.end() || result.second != right.end())
    {
        string leftpos(result.first == left.end() ? "end" : to_string(*result.first));
        string rightpos(result.second == right.end() ? "end" : to_string(*result.second));
        cout << msg << "mismatch. Left iterator at " << leftpos
            << " right iterator at " << rightpos << endl;
    }
    else
    {
        cout << msg << " match." << endl;
    }
}


int main()
{

    vector<int> vec_1{ 0, 5, 10, 15, 20, 25 };
    vector<int> vec_2{ 0, 5, 10, 15, 20, 25, 30 };

    // Testing different length vectors for mismatch (C++03)
    auto match_vecs = mismatch(vec_1.begin(), vec_1.end(), vec_2.begin());
    bool is_mismatch = match_vecs.first != vec_1.end();
    cout << "C++03: vec_1 and vec_2 are a mismatch: " << boolalpha << is_mismatch << endl;

    // Using dual-range overloads:

    // Testing different length vectors for mismatch (C++14)
    match_vecs = mismatch(vec_1.begin(), vec_1.end(), vec_2.begin(), vec_2.end());
    PrintResult("C++14: vec_1 and vec_2: ", match_vecs, vec_1, vec_2);

    // Identify point of mismatch between vec_1 and modified vec_2. 
    vec_2[3] = 42;
    match_vecs = mismatch(vec_1.begin(), vec_1.end(), vec_2.begin(), vec_2.end());
    PrintResult("C++14 vec_1 v. vec_2 modified: ", match_vecs, vec_1, vec_2);

    // Test vec_3 and vec_4 for mismatch under the binary predicate twice (C++14)  
    vector<int> vec_3{ 10, 20, 30, 40, 50, 60 };
    vector<int> vec_4{ 5, 10, 15, 20, 25, 30 };
    match_vecs = mismatch(vec_3.begin(), vec_3.end(), vec_4.begin(), vec_4.end(), twice);
    PrintResult("vec_3 v. vec_4 with pred: ", match_vecs, vec_3, vec_4);

    vec_4[5] = 31;
    match_vecs = mismatch(vec_3.begin(), vec_3.end(), vec_4.begin(), vec_4.end(), twice);
    PrintResult("vec_3 v. modified vec_4 with pred: ", match_vecs, vec_3, vec_4);

    // Compare a vector<int> to a list<int>
    list<int> list_1{ 0, 5, 10, 15, 20, 25 };
    auto match_vec_list = mismatch(vec_1.begin(), vec_1.end(), list_1.begin(), list_1.end());
    is_mismatch = match_vec_list.first != vec_1.end() || match_vec_list.second != list_1.end();
    cout << "vec_1 and list_1 are a mismatch: " << boolalpha << is_mismatch << endl;

    char c;
    cout << "Press a key" << endl;
    cin >> c;

}


/*
Output:
C++03: vec_1 and vec_2 are a mismatch: false
C++14: vec_1 and vec_2: mismatch. Left iterator at end right iterator at 30
C++14 vec_1 v. vec_2 modified: mismatch. Left iterator at 15 right iterator at 42
C++14 vec_3 v. vec_4 with pred:  match.
C++14 vec_3 v. modified vec_4 with pred: mismatch. Left iterator at 60 right iterator at 31
C++14: vec_1 and list_1 are a mismatch: false
Press a key
*/





需求

標頭:<algorithm>

命名空間: std

顯示: