mismatch

Compare l'élément de deux plages par l'élément d'égalité ou l'équivalent dans une certaine mesure spécifié par un attribut binaire et recherche la première position où une différence se produit.

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
   );

Paramètres

• _First1
  Un itérateur d'entrée adressant la position du premier élément de la première plage à tester.

• _Last1
  Un itérateur d'entrée adressant une position au delà de le dernier élément de la première plage à tester.

• _First2
  Un itérateur d'entrée adressant la position du premier élément du deuxième intervalle à tester.

• _Comp
  Objet défini par l'utilisateur de fonction de prédicat qui définit la condition à satisfaire si deux éléments doivent être pris comme équivalents.Un attribut binaire accepte deux arguments et retourne true si satisfaite et false une fois pas de contenu.

Valeur de retour

Une paire d'itérateurs adressant les positions de l'incompatibilité dans les deux plages, du premier itérateur composant à la position de la première plage et le deuxième itérateur composant à la position du deuxième intervalle s'il n'existe aucune différence entre les éléments dans des plages comparés ou si l'attribut binaire dans la deuxième version est contenu par toutes les paires d'éléments des deux plages, puis les premiers points composants d'itérateur vers la position une au delà de le dernier élément de la première plage et le deuxième itérateur composant pour positionner un au delà de le dernier élément a testé dans le deuxième intervalle.

Notes

l'intervalle à rechercher doit être valide ; tous les pointeurs doivent être deréférençables et la dernière position est accessible dès le début par l'augmentation.

La complexité de temps de l'algorithme est linéaire du nombre d'éléments contenus dans la plage.

operator== utilisé pour déterminer l'égalité entre les éléments doit appliquer une relation d'équivalence entre ses opérandes.

Exemple

// alg_mismatch.cpp
// compile with: /EHsc
#include <vector>
#include <list>
#include <algorithm>
#include <iostream>

// Return whether second element is twice the first
bool twice ( int elem1, int elem2 )
{
   return elem1 * 2 == elem2;
}

int main( ) 
{
   using namespace std;
   vector <int> v1, v2;
   list <int> L1;
   vector <int>::iterator Iter1, Iter2;
   list <int>::iterator L1_Iter, L1_inIter;

   int i;
   for ( i = 0 ; i <= 5 ; i++ )
   {
      v1.push_back( 5 * i );
   }

   int ii;
   for ( ii = 0 ; ii <= 7 ; ii++ )
   {
      L1.push_back( 5 * ii );
   }

   int iii;
   for ( iii = 0 ; iii <= 5 ; iii++ )
   {
      v2.push_back( 10 * iii );
   }
   
   cout << "Vector v1 = ( " ;
   for ( Iter1 = v1.begin( ) ; Iter1 != v1.end( ) ; Iter1++ )
      cout << *Iter1 << " ";
   cout << ")" << endl;

   cout << "List L1 = ( " ;
   for ( L1_Iter = L1.begin( ) ; L1_Iter!= L1.end( ) ; L1_Iter++ )
      cout << *L1_Iter << " ";
   cout << ")" << endl;

   cout << "Vector v2 = ( " ;
   for ( Iter2 = v2.begin( ) ; Iter2 != v2.end( ) ; Iter2++ )
      cout << *Iter2 << " ";
      cout << ")" << endl;

   // Testing v1 and L1 for mismatch under identity
   pair<vector <int>::iterator, list <int>::iterator> results1;
   results1 = mismatch (v1.begin( ), v1.end( ), L1.begin( ));

   if ( results1.first == v1.end( ) )
      cout << "The two ranges do not differ."
           << endl;
   else
      cout << "The first mismatch is between "
           << *results1.first << " & " << *results1.second
           << endl;

   // Modifying L1
   L1_inIter = L1.begin( );
   L1_inIter++;
   L1_inIter++;
   L1.insert(L1_inIter, 100);
   cout << "Modified L1 = ( " ;
   for ( L1_Iter = L1.begin( ) ; L1_Iter!= L1.end( ) ; L1_Iter++ )
      cout << *L1_Iter << " ";
   cout << ")" << endl;

   // Testing v1 with modified L1 for mismatch under identity
   results1 = mismatch ( v1.begin( ), v1.end( ), L1.begin( ) );

   if ( results1.first == v1.end( ) )
      cout << "The two ranges do not differ."
           << endl;
   else
      cout << "The first mismatch is between "
           << *results1.first << " & " << *results1.second
           << endl;

   // Test v1 and v2 for mismatch under the binary predicate twice
   pair<vector <int>::iterator, vector <int>::iterator> results2;
   results2 = mismatch ( v1.begin( ), v1.end( ), v2.begin( ), twice );

   if ( results2.first == v1.end( ) )
      cout << "The two ranges do not differ under the binary "
           << "predicate twice." << endl;
   else
      cout << "The first mismatch is between "
           << *results2.first << " & " << *results2.second
           << endl;
}

Configuration requise

en-tête : <algorithm>

l'espace de noms : DST

Voir aussi

Référence

Modèles Standard