mismatch 源码剖析

一：功能解析

函数原型：

equality (1)    
template <class InputIterator1, class InputIterator2>
  pair<InputIterator1, InputIterator2>
    mismatch (InputIterator1 first1, InputIterator1 last1,
              InputIterator2 first2);
predicate (2)   
template <class InputIterator1, class InputIterator2, class BinaryPredicate>
  pair<InputIterator1, InputIterator2>
    mismatch (InputIterator1 first1, InputIterator1 last1,
              InputIterator2 first2, BinaryPredicate pred);

功能：

区间[ first1 , last1 )与以first2开始的区间逐一比较（默认是相等），直至出现不匹配，返回不匹配的迭代器，注意返回类型是pair。

例子：

// mismatch algorithm example
#include <iostream>     // std::cout
#include <algorithm>    // std::mismatch
#include <vector>       // std::vector
#include <utility>      // std::pair

bool mypredicate (int i, int j) {
  return (i==j);
}

int main () {
  std::vector<int> myvector;
  for (int i=1; i<6; i++) myvector.push_back (i*10); // myvector: 10 20 30 40 50

  int myints[] = {10,20,80,320,1024};                //   myints: 10 20 80 320 1024

  std::pair<std::vector<int>::iterator,int*> mypair;

  // using default comparison:
  mypair = std::mismatch (myvector.begin(), myvector.end(), myints);
  std::cout << "First mismatching elements: " << *mypair.first;
  std::cout << " and " << *mypair.second << '\n';

  ++mypair.first; ++mypair.second;

  // using predicate comparison:
  mypair = std::mismatch (mypair.first, myvector.end(), mypair.second, mypredicate);
  std::cout << "Second mismatching elements: " << *mypair.first;
  std::cout << " and " << *mypair.second << '\n';

  return 0;
}

运行如下：

First mismatching elements: 30 and 80
Second mismatching elements: 40 and 320

二：源码剖析

// TEMPLATE FUNCTION mismatch WITH PRED
template<class _InIt1,
    class _InIt2,
    class _Pr> inline
    pair<_InIt1, _InIt2>
        _Mismatch(_InIt1 _First1, _InIt1 _Last1,
            _InIt2 _First2, _Pr _Pred)
    {   // return [_First1, _Last1)/[_First2, ...) mismatch using _Pred
    for (; _First1 != _Last1 && _Pred(*_First1, *_First2); )
        {   // point past match
        ++_First1;
        ++_First2;
        }
    return (pair<_InIt1, _InIt2>(_First1, _First2));
    }

 #if _ITERATOR_DEBUG_LEVEL == 0
template<class _InIt1,
    class _InIt2,
    class _Pr> inline
    pair<_InIt1, _InIt2>
        mismatch(_InIt1 _First1, _InIt1 _Last1,
            _InIt2 _First2, _Pr _Pred)
    {   // return [_First1, _Last1)/[_First2, ...) mismatch using _Pred
    pair<_UNCHECKED_TYPE(_InIt1), _InIt2> _Ans(
        _Mismatch(_Unchecked(_First1), _Unchecked(_Last1),
            _First2, _Pred));
    return (pair<_InIt1, _InIt2>(
        _Rechecked(_First1, _Ans.first),
        _Ans.second));
    }

 #else /* _ITERATOR_DEBUG_LEVEL == 0 */
template<class _InIt1,
    class _InIt2,
    class _Pr> inline
    pair<_InIt1, _InIt2>
        _Mismatch2(_InIt1 _First1, _InIt1 _Last1,
            _InIt2 _First2, _Pr _Pred, true_type)
    {   // return [_First1, _Last1)/[_First2, ...) mismatch, checked input
    return (_Mismatch(_First1, _Last1,
        _First2, _Pred));
    }

template<class _InIt1,
    class _InIt2,
    class _Pr> inline
_SCL_INSECURE_DEPRECATE
    pair<_InIt1, _InIt2>
        _Mismatch2(_InIt1 _First1, _InIt1 _Last1,
            _InIt2 _First2, _Pr _Pred, false_type)
    {   // return [_First1, _Last1)/[_First2, ...) mismatch, unchecked input
    return (_Mismatch(_First1, _Last1,
        _First2, _Pred));
    }

template<class _InIt1,
    class _InIt2,
    class _Pr> inline
    pair<_InIt1, _InIt2>
        mismatch(_InIt1 _First1, _InIt1 _Last1,
            _InIt2 _First2, _Pr _Pred)
    {   // return [_First1, _Last1)/[_First2, ...) mismatch using _Pred
    _DEBUG_RANGE_PTR(_First1, _Last1, _First2);
    _DEBUG_POINTER_IF(_First1 != _Last1, _Pred);
    pair<_UNCHECKED_TYPE(_InIt1), _InIt2> _Ans(
        _Mismatch2(_Unchecked(_First1), _Unchecked(_Last1),
            _First2, _Pred, _Is_checked(_First2)));
    return (pair<_InIt1, _InIt2>(
        _Rechecked(_First1, _Ans.first),
        _Ans.second));
    }

 #if _ITERATOR_DEBUG_ARRAY_OVERLOADS
template<class _InIt1,
    class _InTy,
    size_t _InSize,
    class _Pr> inline
    pair<_InIt1, _InTy *>
        mismatch(_InIt1 _First1, _InIt1 _Last1,
            _InTy (&_First2)[_InSize], _Pr _Pred)
    {   // return [_First1, _Last1)/[_First2, ...) mismatch using _Pred
    pair<_InIt1, _Array_iterator<_InTy, _InSize> > _Ans(
        _STD mismatch(_First1, _Last1,
            _Array_iterator<_InTy, _InSize>(_First2), _Pred));
    return (pair<_InIt1, _InTy *>(
        _Ans.first,
        _Unchecked(_Ans.second)));
    }
 #endif /* _ITERATOR_DEBUG_ARRAY_OVERLOADS */
 #endif /* _ITERATOR_DEBUG_LEVEL == 0 */

        // TEMPLATE FUNCTION mismatch
template<class _InIt1,
    class _InIt2> inline
    pair<_InIt1, _InIt2>
        mismatch(_InIt1 _First1, _InIt1 _Last1,
            _InIt2 _First2)
    {   // return [_First1, _Last1)/[_First2, ...) mismatch
    return (_STD mismatch(_First1, _Last1, _First2,
        equal_to<>()));
    }

 #if _ITERATOR_DEBUG_ARRAY_OVERLOADS
template<class _InIt1,
    class _InTy,
    size_t _InSize> inline
    pair<_InIt1, _InTy *>
        mismatch(_InIt1 _First1, _InIt1 _Last1,
            _InTy (&_First2)[_InSize])
    {   // return [_First1, _Last1)/[_First2, ...) mismatch, array input
    return (_STD mismatch(_First1, _Last1, _First2,
        equal_to<>()));
    }
 #endif /* _ITERATOR_DEBUG_ARRAY_OVERLOADS */

        // TEMPLATE FUNCTION mismatch WITH TWO RANGES, PRED
template<class _InIt1,
    class _InIt2,
    class _Pr> inline
    pair<_InIt1, _InIt2>
        _Mismatch(_InIt1 _First1, _InIt1 _Last1,
            _InIt2 _First2, _InIt2 _Last2, _Pr _Pred)
    {   // return [_First1, _Last1)/[_First2, _Last2) mismatch using _Pred
    for (; _First1 != _Last1 && _First2 != _Last2
        && _Pred(*_First1, *_First2); )
        {   // point past match
        ++_First1;
        ++_First2;
        }
    return (pair<_InIt1, _InIt2>(_First1, _First2));
    }

template<class _InIt1,
    class _InIt2,
    class _Pr> inline
    pair<_InIt1, _InIt2>
        mismatch(_InIt1 _First1, _InIt1 _Last1,
            _InIt2 _First2, _InIt2 _Last2, _Pr _Pred)
    {   // return [_First1, _Last1)/[_First2, _Last2) mismatch using _Pred
    _DEBUG_RANGE(_First1, _Last1);
    _DEBUG_RANGE(_First2, _Last2);
    _DEBUG_POINTER_IF(_First1 != _Last1 && _First2 != _Last2, _Pred);
    pair<_UNCHECKED_TYPE(_InIt1), _UNCHECKED_TYPE(_InIt2)> _Ans(
        _Mismatch(_Unchecked(_First1), _Unchecked(_Last1),
            _Unchecked(_First2), _Unchecked(_Last2), _Pred));
    return (pair<_InIt1, _InIt2>(
        _Rechecked(_First1, _Ans.first),
        _Rechecked(_First2, _Ans.second)));
    }

        // TEMPLATE FUNCTION mismatch WITH TWO RANGES
template<class _InIt1,
    class _InIt2> inline
    pair<_InIt1, _InIt2>
        mismatch(_InIt1 _First1, _InIt1 _Last1,
            _InIt2 _First2, _InIt2 _Last2)
    {   // return [_First1, _Last1)/[_First2, _Last2) mismatch
    return (_STD mismatch(_First1, _Last1, _First2, _Last2,
        equal_to<>()));
    }

代码看着挺多，其实不难。

源码摘抄自Visual Studio 2015安装目录algorithm文件中。

点击进入目录----> C++源码剖析目录