C++ Primer 学习中。

。

。

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

全部容器适用

unique(b,e)

unique(b,e,p)

unique_copy(b1,e1,b2)

unique_copy(b1,e1,b2,p)

注意：

    1、没有unique_if()

    2、没有unique_copy_if()

/**------http://blog.csdn.net/u010579068------**/

#include<iostream>

#include<cstdio>

#include<string>

#include<vector>

#include<list>

#include<deque>

#include<algorithm>

using namespace std;

/*****************************************

//全部容器适用

unique(b,e)

unique(b,e,p)

unique_copy(b1,e1,b2)

unique_copy(b1,e1,b2,p)

注意：

    1、没有unique_if()

    2、没有unique_copy_if()

*****************************************/

/**----------------------------------------------------------------------------------

使用方法：删除连续的、反复的元素

----------------------------------------------------------------------------------**/

/*************************************************************************************

std::unique                     全部排序容器适用                           algorithm

--------------------------------------------------------------------------------------

template <class ForwardIterator>

  ForwardIterator unique ( ForwardIterator first, ForwardIterator last );

template <class ForwardIterator, class BinaryPredicate>

  ForwardIterator unique ( ForwardIterator first, ForwardIterator last,

                           BinaryPredicate pred );

//eg：

template <class ForwardIterator>

  ForwardIterator unique ( ForwardIterator first, ForwardIterator last )

{

  ForwardIterator result=first;

  while (++first != last)

  {

    if (!(*result == *first))  // or: if (!pred(*result,*first)) for the pred version

      *(++result)=*first;

  }

  return ++result;

}

*************************************************************************************/

/*************************************************************************************

std::unique_copy                   全部排序容器适用                        algorithm

--------------------------------------------------------------------------------------

template <class InputIterator, class OutputIterator>

  OutputIterator unique_copy ( InputIterator first, InputIterator last,

                               OutputIterator result );

template <class InputIterator, class OutputIterator, class BinaryPredicate>

  OutputIterator unique_copy ( InputIterator first, InputIterator last,

                               OutputIterator result, BinaryPredicate pred );

//eg：

template <class InputIterator, class OutputIterator>

  OutputIterator unique_copy ( InputIterator first, InputIterator last,

                               OutputIterator result )

{

  typename std::iterator_traits<InputIterator>::value_type value = *first;

  *result=*first;

  while (++first != last)

  {

    if (!(value == *first))  // or: if (!pred(value,*first)) for the pred version

      *(++result) = value = *first;

  }

  return ++result;

}

*************************************************************************************/

bool myfunction (int i, int j)

{

    return (i==j);

}

template<typename T>

void Print(T& V)

{

    typename T::iterator iter=V.begin();

    while(iter != V.end())

    {

        cout<<*iter++<<" ";

    }

    cout<<endl;

}

int main()

{

    int myints[] = {10,20,20,20,30,30,20,20,10};    // 10 20 20 20 30 30 20 20 10

    vector<int> myvector (myints,myints+9);

    vector<int>::iterator it,pend;

    // using default comparison:

    it = unique (myvector.begin(), myvector.end()); // 10 20 30 20 10 ?  ?

?

?

    //                ^

    myvector.resize( it - myvector.begin() );       // 10 20 30 20 10

    // using predicate comparison:

    unique (myvector.begin(), myvector.end(), myfunction);   // (no changes)

    // print out content:

    cout << "myvector contains:";

    for (it=myvector.begin(); it!=myvector.end(); ++it)

        cout << " " << *it;

    cout << endl;

    vector<int> vec;

    copy(myints,myints+9,back_inserter(vec));

    Print(vec);

    pend =unique(vec.begin(),vec.end(),greater<int>());//取单调不递减数列

    cout << "vec contains:";

    for (it=vec.begin(); it!=pend; ++it)

        cout << " " << *it;

    cout << endl << endl;

    /**--------------------------------------------------------------------------------**/

//    int myints[] = {10,20,20,20,30,30,20,20,10};

    deque<int> mydeque (9);                            // 0  0  0  0  0  0  0  0  0

    deque<int>::iterator id;

    // using default comparison:

    id=unique_copy (myints,myints+9,mydeque.begin());   // 10 20 30 20 10 0  0  0  0

    //                ^

    sort (mydeque.begin(),id);                          // 10 10 20 20 30 0  0  0  0

    //                ^

    // using predicate comparison:

    id=unique_copy (mydeque.begin(), id, mydeque.begin(), myfunction);

    // 10 20 30 20 30 0  0  0  0

    //          ^

    mydeque.resize( id - mydeque.begin() );            // 10 20 30

    // print out content:

    cout << "mydeque contains:";

    for (id=mydeque.begin(); id!=mydeque.end(); ++id)

        cout << " " << *id;

    cout << endl;

    return 0;

}