整理下STL algorithms（2）

copy：

#include <algorithm>
template< class InputIterator, class OutputIterator >
OutputIterator copy( InputIterator first, InputIterator last, OutputIterator d_first );

该方法会将first到last之间的元素拷贝到d_first之中~~

相当于如下实现：

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

是从后边拷贝~~

#include <algorithm>
#include <iostream>
 
int main()
{
    std::vector<int> from_vector;
    for (int i = 0; i < 10; i++) {
        from_vector.push_back(i);
    }
 
    std::vector<int> to_vector(15);
 
    std::copy_backward(from_vector.begin(), from_vector.end(), to_vector.end());
 
    std::cout << "to_vector contains: ";
    for (unsigned int i = 0; i < to_vector.size(); i++) {
        std""cout << to_vector[i] << " ";
    }
 
    return 0;
}

to_vector contains: 0 0 0 0 0 0 1 2 3 4 5 6 7 8 9

#include <algorithm>
 
template< class ForwardIterator, class T >
void fill( ForwardIterator first, ForwardIterator last, const T& value );

fill_n:

template < class OutputIterator, class Size, class T >
  void fill_n ( OutputIterator first, Size n, const T& value );

transform:

template< class InputIterator, class OutputIterator, class UnaryOperation >
OutputIterator transform( InputIterator first1, InputIterator last1,
                          OutputIterator d_first, UnaryOperation unary_op );
 
template< class InputIterator1, class InputIterator2, class OutputIterator, class BinaryOperation >
OutputIterator transform( InputIterator first1, InputIterator last1,
                          InputIterator first2, OutputIterator d_first, BinaryOperation binary_op );

first2是第二个序列的起始元素~

如下的字符串转大写方法~：

#include <string>
#include <algorithm>
#include <iostream>
 
int main()
{
    std::string s("hello");
    std::transform(s.begin(), s.end(), s.begin(), (int (*)(int))toupper);
    std::cout << s;
 
    return 0;
}

generate：

template< class ForwardIterator, class Generator >
void generate( ForwardIterator first, ForwardIterator last, Generator g );

可以使用如下代码产生随机序列~

#include <algorithm>
#include <iostream>
#include <cstdlib>
 
int main()
{
    std::vector<int> v(5);
    std::generate(v.begin(), v.end(), std::rand); // Using the C function rand()
 
    std::cout << "v: ";
    for (vector<int>::iterator it = v.begin(); it != v.end(); ++it) {
        std::cout << v[i] << ' ';
    }
 
    return 0;
}

类似的是generate_n:

template< class OutputIterator, class Size, class Generator >
void generate_n( OutputIterator first, Size count, Generator g );

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

删除first和last之间值为value的元素~~

类似的有remove_if:

template< class ForwardIterator, class UnaryPredicate >
ForwardIterator remove_if( ForwardIterator first, ForwardIterator last, UnaryPredicate p );

template< class InputIterator, class OutputIterator, class T >
OutputIterator remove_copy( InputIterator first,
                            InputIterator last,
                            OutputIterator d_first,
                            const T& value );

template< class ForwardIterator, class T >
void replace( ForwardIterator first, ForwardIterator last,
              const T& old_value, const T& new_value );

swap:

template <class T> void swap ( T& a, T& b );

交换a和b的值~~

template <class T> void swap ( T& a, T& b )
{
  T c(a); a=b; b=c;
}

template < class ForwardIterator1, class ForwardIterator2 >
  ForwardIterator2 swap_ranges ( ForwardIterator1 first1, ForwardIterator1 last1,
                                 ForwardIterator2 first2 );

 vector<int> first (5,10);        //  first: 10 10 10 10 10
  vector<int> second (5,33);       // second: 33 33 33 33 33
  vector<int>::iterator it;

  swap_ranges(first.begin()+1, first.end()-1, second.begin());

结果为：first contains: 10 33 33 33 10
second contains: 10 10 10 33 33

template <class ForwardIterator1, class ForwardIterator2>
  void iter_swap ( ForwardIterator1 a, ForwardIterator2 b );

partition：

template <class BidirectionalIterator, class Predicate>
  BidirectionalIterator partition ( BidirectionalIterator first,
                                    BidirectionalIterator last, Predicate pred );

该方法会打乱同类元素的顺序，而stable_partition能保持顺序~

reverse（反转）:

template< class BidirectionalIterator >
void reverse( BidirectionalIterator first, BidirectionalIterator last );

template <class BidirectionalIterator, class OutputIterator>
  OutputIterator reverse_copy ( BidirectionalIterator first,
                                BidirectionalIterator last, OutputIterator result );

rotate(旋转):

template <class ForwardIterator>
  void rotate ( ForwardIterator first, ForwardIterator middle,
                ForwardIterator last );

random_shuffle（随机打乱）：

template <class RandomAccessIterator>
  void random_shuffle ( RandomAccessIterator first, RandomAccessIterator last );

template <class RandomAccessIterator, class RandomNumberGenerator>
  void random_shuffle ( RandomAccessIterator first, RandomAccessIterator last,
                        RandomNumberGenerator& rand );

template< class ForwardIterator >
ForwardIterator unique( ForwardIterator first, ForwardIterator last );
 
template< class ForwardIterator, class BinaryPredicate >
ForwardIterator unique( ForwardIterator first, ForwardIterator last, BinaryPredicate p );