std::pair, std::copy, std::lower_bound, std::back_insert使用

std::pair

首先给出std::pair的class定义:

template <class T1, class T2> struct pair
{
  typedef T1 first_type;
  typedef T2 second_type;

  T1 first;
  T2 second;
  pair() : first(T1()), second(T2()) {}
  pair(const T1& x, const T2& y) : first(x), second(y) {}
  template <class U, class V>
    pair (const pair<U,V> &p) : first(p.first), second(p.second) { }
}

可见std::pair的两个成员first和second都是公有的，从而可以直接对其进行访问.
这里主要说明std::pairs是可以直接做比较的,现引用官方的一句话：
The header <utility> also overloads the relational operators ==, <, !=, >, >= and <= , 
so as to be able to compare pair objects of the same type directly:


Two pair objects are compared equal if the first elements in both objects compare equal to each other 
and both second elements also compare equal to each other - they all have to match.


In inequality comparisons (<, >), the first elements are compared first, and only if the inequality comparison 
is not true for them, the second elements are compared.


简单解释一下:对std::pair的比较做了一个重载，首先比较第一个成员函数，如果相等，在比较第二个成员,只有当两个成员
都相等的情况下，std::pair才算相等！这里可以简单实现伪代码如下:

//! 1 >; 2 < ; 3=
int operators == (std::pair& pair1_, std::pair& pari2_)
{
if (pair1_.first > pari2_.first)
{
 return 1;  
}
else if (pair1_.first < pari2_.first)
{
  return 2;
}
else
{
if (pair1_.second > pari2_.second)
{
 return 1;  
}
else if (pair1_.second < pari2_.second)
{
  return 2;
}
}

return 0;
	
}

std::lower_bound
反回有序序列中第一个满足条件的元素迭代器,给出它的两种声明，一种是默认以operator<，进行比较，
另一种以传放的仿函数做比较！

template <class ForwardIterator, class T>
  ForwardIterator lower_bound ( ForwardIterator first, ForwardIterator last,
                                const T& value );

template <class ForwardIterator, class T, class Compare>
  ForwardIterator lower_bound ( ForwardIterator first, ForwardIterator last,
                                const T& value, Compare comp );

同样引用一句话：
Returns an iterator pointing to the first element in the sorted range [first,last) which does not compare less than value. 
The comparison is done using either operator< for the first version, or comp for the second.

std::copy
Copies the elements in the range [first,last) into the range beginning at result.
The function returns an iterator to the end of the destination range (which points to the element following the copy of last).
定义如下：

template<class InputIterator, class OutputIterator>
  OutputIterator copy (InputIterator first, InputIterator last, OutputIterator result)
{
  while (first!=last) {
    *result = *first;
    ++result; ++first;
  }
  return result;
}

它通常配合std::back_insert 使用，以push_back的形式复制元素到新的容器中，也就是说，目标容器必须要有push_back成员函数。
当然还有一点，尽量不要自己复制自己！


那么下面给一个完整的例子！

#include <iostream>                                                                                                                                      
using namespace std;

#include <set>
#include <vector>
#include <algorithm>

struct compare_t
{
    bool operator() (const std::pair<int, double>& pair1_, const std::pair<int, double>& pair2_)
    {
        return pair1_.first < pair2_.first;
    }
};

int main()
{
    //! first member compare first, and then second
    std::pair<int, double> test1(1, 2.0);
    std::pair<int, double> test2(2, 2.2);
    std::pair<int, double> test3(1, 2.3);
    std::pair<int, double> test4(1, 2.4);

    cout << (test1 < test2) << endl; // 1
    cout << (test2 < test3) << endl; // 0
    cout << (test3 < test4) << endl; // 1
    cout << (test3 < test1) << endl; // 0
    cout << endl;

    std::set<std::pair<int, double>, compare_t> elements;
    elements.insert(test1);
    elements.insert(test2);
    elements.insert(test3);
    elements.insert(test4);
    for (std::set<std::pair<int, double>, compare_t>::iterator it = elements.begin(); it != elements.end(); ++it)
    {
        cout << it->first << ":" << it->second << endl;
    }

    std::pair<int, double> test5(3, 2.4);
    std::set<std::pair<int, double>, compare_t>::iterator it = std::lower_bound(elements.begin(), elements.end(), test5, compare_t());
    //std::set<std::pair<int, double>, compare_t>::iterator it = elements.lower_bound(test5);
    if (it == elements.end())
    {
        cout << "not foud" << endl;
    }
    else
    {
        cout << it->first << ":" << it->second << endl;
    }
    
    std::vector<std::pair<int, double> > elements_test;
    std::copy(elements.begin(), it, std::back_inserter(elements_test));
    cout << endl << endl;
    for (std::vector<std::pair<int, double> >::iterator it = elements_test.begin(); it != elements_test.end(); ++it)
    {
        cout << it->first << ":" << it->second << endl;
    }

    //!拷贝到自己：
    std::copy(elements_test.begin(), elements_test.end(), std::back_inserter(elements_test));
    cout << endl << endl;
    for (std::vector<std::pair<int, double> >::iterator it = elements_test.begin(); it != elements_test.end(); ++it)
    {
        cout << it->first << ":" << it->second << endl;
    }
    return 0;
}