std::mismatch

Défini dans l'en-tête `<algorithm>`
template< class InputIt1, class InputIt2 > std::pair<InputIt1, InputIt2> mismatch( InputIt1 first1, InputIt1 last1, InputIt2 first2 );	(1)	(constexpr depuis C++20)
template< class ExecutionPolicy, class ForwardIt1, class ForwardIt2 > std::pair<ForwardIt1, ForwardIt2> mismatch( ExecutionPolicy&& policy, ForwardIt1 first1, ForwardIt1 last1, ForwardIt2 first2 );	(2)	(depuis C++17)
template< class InputIt1, class InputIt2, class BinaryPred > std::pair<InputIt1, InputIt2> mismatch( InputIt1 first1, InputIt1 last1, InputIt2 first2, BinaryPred p );	(3)	(constexpr depuis C++20)
template< class ExecutionPolicy, class ForwardIt1, class ForwardIt2, class BinaryPred > std::pair<ForwardIt1, ForwardIt2> mismatch( ExecutionPolicy&& policy, ForwardIt1 first1, ForwardIt1 last1, ForwardIt2 first2, BinaryPred p );	(4)	(depuis C++17)
template< class InputIt1, class InputIt2 > std::pair<InputIt1, InputIt2> mismatch( InputIt1 first1, InputIt1 last1, InputIt2 first2, InputIt2 last2 );	(5)	(depuis C++14) (constexpr depuis C++20)
template< class ExecutionPolicy, class ForwardIt1, class ForwardIt2 > std::pair<ForwardIt1, ForwardIt2> mismatch( ExecutionPolicy&& policy, ForwardIt1 first1, ForwardIt1 last1, ForwardIt2 first2, ForwardIt2 last2 );	(6)	(depuis C++17)
template< class InputIt1, class InputIt2, class BinaryPred > std::pair<InputIt1, InputIt2> mismatch( InputIt1 first1, InputIt1 last1, InputIt2 first2, InputIt2 last2, BinaryPred p );	(7)	(depuis C++14) (constexpr depuis C++20)
template< class ExecutionPolicy, class ForwardIt1, class ForwardIt2, class BinaryPred > std::pair<ForwardIt1, ForwardIt2> mismatch( ExecutionPolicy&& policy, ForwardIt1 first1, ForwardIt1 last1, ForwardIt2 first2, ForwardIt2 last2, BinaryPred p );	(8)	(depuis C++17)

Renvoie une paire d'itérateurs vers la première non-concordance d'éléments entre [first1, last1) et une plage commençant à first2 :

Pour les surcharges (1-4), la seconde plage a std::distance(first1, last1) éléments.
Pour les surcharges (5-8), la seconde plage est [first2, last2).

Si std::distance(first1, last1) et std::distance(first2, last2) sont différents, la comparaison s'arrête lorsque last1 ou last2 est atteint.

1,5) Les éléments sont comparés à l'aide de operator==.

3,7) Les éléments sont comparés à l'aide du prédicat binaire donné p.

2,4,6,8) Identique à (1,3,5,7), mais exécuté selon policy.

Ces surcharges ne participent à la résolution de surcharge que si la valeur de l'expression suivante est true :

`std::is_execution_policy_v<std::decay_t<ExecutionPolicy>>`	(jusqu'à C++20)
`std::is_execution_policy_v<std::remove_cvref_t<ExecutionPolicy>>`	(depuis C++20)

Paramètres

first1, last1	-	la paire d'itérateurs définissant la première plage d'éléments à comparer
first2, last2	-	la paire d'itérateurs définissant la seconde plage d'éléments à comparer
policy	-	la politique d'exécution à utiliser
p	-	prédicat binaire qui retourne `true` si les éléments doivent être considérés comme égaux. La signature de la fonction prédicat doit être équivalente à ce qui suit : `bool pred(const Type1 &a, const Type2 &b);` Bien que la signature n'ait pas besoin d'avoir `const &`, la fonction ne doit pas modifier les objets qui lui sont passés et doit pouvoir accepter toutes les valeurs de type (éventuellement const) `Type1` et `Type2` indépendamment de la catégorie de valeur (ainsi, `Type1 &` n'est pas autorisé, ni `Type1` sauf si pour `Type1` un déplacement équivaut à une copie(depuis C++11)). Les types `Type1` et `Type2` doivent être tels que les objets de types `InputIt1` et `InputIt2` puissent être déréférencés puis convertis implicitement en `Type1` et `Type2` respectivement.
Exigences de type
- `InputIt1` doit satisfaire aux exigences de LegacyInputIterator.
- `InputIt2` doit satisfaire aux exigences de LegacyInputIterator.
- `ForwardIt1` doit satisfaire aux exigences de LegacyForwardIterator.
- `ForwardIt2` doit satisfaire aux exigences de LegacyForwardIterator.
- `BinaryPred` doit satisfaire aux exigences de BinaryPredicate.

Valeur de retour

std::pair avec des itérateurs vers les deux premiers éléments non égaux.

Si last1 est atteint, le deuxième itérateur de la paire est le std::distance(first1, last1)e itérateur après first2.

Pour les surcharges (5-8), si last2 est atteint, le premier itérateur de la paire est le std::distance(first2, last2)e itérateur après first1.

Complexité

Étant donné $\scriptsize N_1$ $N 1$ comme std::distance(first1, last1) et $\scriptsize N_2$ $N 2$ comme std::distance(first2, last2) :

1,2) Au plus

N 1

comparaisons utilisant operator==.

3,4) Au plus

N 1

applications du prédicat p.

5,6) Au plus

min(N 1,N 2)

comparaisons utilisant operator==.

7,8) Au plus

min(N 1,N 2)

applications du prédicat p.

Exceptions

Les surcharges avec un paramètre template nommé ExecutionPolicy signalent les erreurs comme suit :

Si l'exécution d'une fonction invoquée dans le cadre de l'algorithme lève une exception et que ExecutionPolicy est l'une des politiques standard, std::terminate est appelé. Pour tout autre ExecutionPolicy, le comportement est défini par l'implémentation.
Si l'algorithme échoue à allouer de la mémoire, std::bad_alloc est levé.

Implémentation possible

mismatch (1)
template<class InputIt1, class InputIt2> std::pair<InputIt1, InputIt2> mismatch(InputIt1 first1, InputIt1 last1, InputIt2 first2) { while (first1 != last1 && first1 == first2) ++first1, ++first2; return std::make_pair(first1, first2); }
mismatch (3)
template<class InputIt1, class InputIt2, class BinaryPred> std::pair<InputIt1, InputIt2> mismatch(InputIt1 first1, InputIt1 last1, InputIt2 first2, BinaryPred p) { while (first1 != last1 && p(first1, first2)) ++first1, ++first2; return std::make_pair(first1, first2); }
mismatch (5)
template<class InputIt1, class InputIt2> std::pair<InputIt1, InputIt2> mismatch(InputIt1 first1, InputIt1 last1, InputIt2 first2, InputIt2 last2) { while (first1 != last1 && first2 != last2 && first1 == first2) ++first1, ++first2; return std::make_pair(first1, first2); }
mismatch (7)
template<class InputIt1, class InputIt2, class BinaryPred> std::pair<InputIt1, InputIt2> mismatch(InputIt1 first1, InputIt1 last1, InputIt2 first2, InputIt2 last2, BinaryPred p) { while (first1 != last1 && first2 != last2 && p(first1, first2)) ++first1, ++first2; return std::make_pair(first1, first2); }

Exemple

Ce programme détermine la plus longue sous-chaîne qui se trouve simultanément au tout début de la chaîne donnée et à la toute fin de celle-ci, dans l'ordre inverse (éventuellement avec chevauchement).

Exécuter ce code

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

std::string mirror_ends(const std::string& in)
{
    return std::string(in.begin(),
                       std::mismatch(in.begin(), in.end(), in.rbegin()).first);
}

int main()
{
    std::cout << mirror_ends("abXYZba") << '\n'
              << mirror_ends("abca") << '\n'
              << mirror_ends("aba") << '\n';
}

Sortie :

ab
a
aba

Voir aussi

equal	détermine si deux ensembles d'éléments sont identiques (modèle de fonction & objet fonction d'algorithme)
ranges::equal (C++20)
findfind_iffind_if_not (C++11)	trouve le premier élément satisfaisant des critères spécifiques (modèle de fonction & objet fonction d'algorithme)
ranges::findranges::find_ifranges::find_if_not (C++20)(C++20)(C++20)
lexicographical_compare	compare deux plages lexicographiquement (modèle de fonction & objet fonction d'algorithme)
ranges::lexicographical_compare (C++20)
search	recherche la première occurrence d'une plage d'éléments (modèle de fonction & objet fonction d'algorithme)
ranges::search (C++20)
ranges::mismatch (C++20)	trouve la première position où deux plages diffèrent (objet fonction d'algorithme)

Support du compilateur
Environnements autonome et hébergé
Langage
Bibliothèque standard
En-têtes de la bibliothèque standard
Exigences nommées
Macros de test de fonctionnalités (C++20)
Bibliothèque de support du langage
Bibliothèque de concepts (C++20)
Bibliothèque de diagnostics
Bibliothèque de gestion de la mémoire
Bibliothèque de métaprogrammation (C++11)
Bibliothèque d'utilitaires généraux
Bibliothèque de conteneurs
Bibliothèque d'itérateurs
Bibliothèque de plages (C++20)
Bibliothèque d'algorithmes
Bibliothèque de chaînes
Bibliothèque de traitement de texte
Bibliothèque numérique
Bibliothèque de date et heure
Bibliothèque d'entrée/sortie
Bibliothèque de système de fichiers (C++17)
Bibliothèque de support de la concurrence (C++11)
Bibliothèque de contrôle d'exécution (C++26)
Spécifications techniques
Index des symboles
Bibliothèques externes

fr.cppreference.net

Namespaces

Variants