C++ Primer 学习中。。

。

 

简单记录下我的学习过程 (代码为主)

//全部容器适用

equal(b,e,b2)       //用来比較第一个容器[b,e)和第二个容器b2开头，是否相等
equal(b,e,b2,p)

mismatch(b,e,b2)    //用来查找两个容器中第一个不相等的数据,返回迭代器
mismatch(b,e,b2,p)

lexicographical_compare(b,e,b2,e2)      //用来比較第一个区间是否比第二个区间小
lexicographical_compare(b,e,b2,e2,p)

#include<iostream>
#include<cstdio>
#include<cstring>
#include<vector>
#include<list>
#include<algorithm>
using namespace std;

/*****************************************
//全部容器适用
equal(b,e,b2)       //用来比較第一个容器[b,e)和第二个容器b2开头。是否相等
equal(b,e,b2,p)
mismatch(b,e,b2)    //用来查找两个容器中第一个不相等的数据,返回迭代器
mismatch(b,e,b2,p)
lexicographical_compare(b,e,b2,e2)      //用来比較第一个区间是否比第二个区间小
lexicographical_compare(b,e,b2,e2,p)
*****************************************/

/*************************************************************************************
std::equal                     全部排序容器适用                           algorithm
--------------------------------------------------------------------------------------
template <class InputIterator1, class InputIterator2>
  bool equal ( InputIterator1 first1, InputIterator1 last1,
               InputIterator2 first2 );

template <class InputIterator1, class InputIterator2, class BinaryPredicate>
  bool equal ( InputIterator1 first1, InputIterator1 last1,
               InputIterator2 first2, BinaryPredicate pred );

//eg：
template <class InputIterator1, class InputIterator2>
  bool equal ( InputIterator1 first1, InputIterator1 last1, InputIterator2 first2 )
{
  while ( first1!=last1 )
  {
    if (!(*first1 == *first2))   // or: if (!pred(*first1,*first2)), for pred version
      return false;
    ++first1; ++first2;
  }
  return true;
}
*************************************************************************************/

/*************************************************************************************
std::mismatch                   全部排序容器适用                           algorithm
--------------------------------------------------------------------------------------
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 pred );

//eg：
template <class InputIterator1, class InputIterator2>
  pair<InputIterator1, InputIterator2>
    mismatch (InputIterator1 first1, InputIterator1 last1, InputIterator2 first2 )
{
  while ( (first1!=last1) && (*first1==*first2) )  // or: pred(*first1,*first2), for the pred version
  { ++first1; ++first2; }
  return make_pair(first1,first2);
}
*************************************************************************************/
/*************************************************************************************
std::lexicographical_compare               全部排序容器适用                 algorithm
--------------------------------------------------------------------------------------
template <class InputIterator1, class InputIterator2>
  bool lexicographical_compare ( InputIterator1 first1, InputIterator1 last1,
                                 InputIterator2 first2, InputIterator2 last2 );

template <class InputIterator1, class InputIterator2, class Compare>
  bool lexicographical_compare ( InputIterator1 first1, InputIterator1 last1,
                                 InputIterator2 first2, InputIterator2 last2,
                                 Compare comp );
//eg：
template <class InputIterator1, class InputIterator2>
  bool lexicographical_compare ( InputIterator1 first1, InputIterator1 last1,
                                 InputIterator2 first2, InputIterator2 last2 )
{
  while (first1!=last1)
  {
    if (first2==last2 || *first2<*first1) return false;
    else if (*first1<*first2) return true;
    first1++; first2++;
  }
  return (first2!=last2);
}
*************************************************************************************/

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

bool mycomp (char c1, char c2)
{
    return tolower(c1)<tolower(c2);
}

int main()
{

    //equal(b,e,b2)       //用来比較第一个容器[b,e)和第二个容器b2开头，是否相等
    //equal(b,e,b2,p)

    int myints[] = {20,40,60,80,100};          //   myints: 20 40 60 80 100
    vector<int>myvector (myints,myints+5);     // myvector: 20 40 60 80 100

    // using default comparison:
    if (equal (myvector.begin(), myvector.end(), myints))
        cout << "The contents of both sequences are equal." << endl;
    else
        cout << "The contents of both sequences differ." << endl;

    myvector[3]=81;                            // myvector: 20 40 60 81 100

    // using predicate comparison:
    if (equal (myvector.begin(), myvector.end(), myints, mypredicate))
        cout << "The contents of both sequences are equal." << endl;
    else
        cout << "The contents of both sequences differ." << endl;
    cout<<endl;
    /**-----------------------------------------------------------------------------
    Output:
        The contents of both sequences are equal.
        The contents of both sequences differ.
    -----------------------------------------------------------------------------**/

    //mismatch(b,e,b2)    //用来查找两个容器中第一个不相等的数据,返回迭代器
    //mismatch(b,e,b2,p)

    list<int> mylist;
    for (int i=1; i<6; i++) mylist.push_back (i*10);   // mylist: 10 20 30 40 50

    int myints2[] = {10,20,80,40,1024};              // myints2: 10 20 80 40 1024

    pair<list<int>::iterator,int*> mypair;

    // using default comparison:
    mypair = mismatch (mylist.begin(), mylist.end(), myints2);
    cout << "First mismatching elements: " << *mypair.first;
    cout << " and " << *mypair.second << endl;

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

    // using predicate comparison:
    mypair = mismatch (mypair.first, mylist.end(), mypair.second, mypredicate);
    cout << "Second mismatching elements: " << *mypair.first;
    cout << " and " << *mypair.second << endl;
    cout <<endl;

    /**-----------------------------------------------------------------------------
    Output:
        First mismatching elements: 30 and 80
        Second mismatching elements: 50 and 1024
    -----------------------------------------------------------------------------**/

    //lexicographical_compare(b,e,b2,e2)      //用来比較第一个区间是否比第二个区间小  (长度和ASCII码)
    //lexicographical_compare(b,e,b2,e2,p)

    char first[]="apple";         // 5 letters
    char second[]="apart";        // 5 letters   eg:apartment

    cout << "Using default comparison (operator<): ";
    if (lexicographical_compare(first,first+5,second,second+5))
        cout << first << " is less than " << second << endl;
    else if (lexicographical_compare(second,second+5,first,first+5))
        cout << first << " is greater than " << second << endl;
    else
        cout << first << " and " << second << " are equivalent\n";


    cout << "Using mycomp as comparison object: ";
    if (lexicographical_compare(first,first+5,second,second+5,mycomp))
        cout << first << " is less than " << second << endl;
    else if (lexicographical_compare(second,second+5,first,first+5,mycomp))
        cout << first << " is greater than " << second << endl;
    else
        cout << first << " and " << second << " are equivalent\n";
    /**-----------------------------------------------------------------------------
    Output:
        Using default comparison (operator<): apple is greater than apart
        Using mycomp as comparison object: apple is greater than apart
    -----------------------------------------------------------------------------**/

    return 0;
}