Boost C++ Libraries

...one of the most highly regarded and expertly designed C++ library projects in the world. Herb Sutter and Andrei Alexandrescu, C++ Coding Standards

This is the documentation for an old version of boost. Click here for the latest Boost documentation.
PrevUpHomeNext

Reference

Header <boost/algorithm/algorithm.hpp>
Header <boost/algorithm/clamp.hpp>
Header <boost/algorithm/cxx11/all_of.hpp>
Header <boost/algorithm/cxx11/any_of.hpp>
Header <boost/algorithm/cxx11/copy_if.hpp>
Header <boost/algorithm/cxx11/copy_n.hpp>
Header <boost/algorithm/cxx11/find_if_not.hpp>
Header <boost/algorithm/cxx11/iota.hpp>
Header <boost/algorithm/cxx11/is_partitioned.hpp>
Header <boost/algorithm/cxx11/is_permutation.hpp>
Header <boost/algorithm/cxx14/is_permutation.hpp>
Header <boost/algorithm/cxx11/is_sorted.hpp>
Header <boost/algorithm/cxx11/none_of.hpp>
Header <boost/algorithm/cxx11/one_of.hpp>
Header <boost/algorithm/cxx11/partition_copy.hpp>
Header <boost/algorithm/cxx11/partition_point.hpp>
Header <boost/algorithm/cxx14/equal.hpp>
Header <boost/algorithm/cxx14/mismatch.hpp>
Header <boost/algorithm/gather.hpp>
Header <boost/algorithm/hex.hpp>
Header <boost/algorithm/is_palindrome.hpp>
Header <boost/algorithm/minmax.hpp>
Header <boost/algorithm/minmax_element.hpp>
Header <boost/algorithm/searching/boyer_moore.hpp>
Header <boost/algorithm/searching/boyer_moore_horspool.hpp>
Header <boost/algorithm/searching/knuth_morris_pratt.hpp>
Header <boost/algorithm/sort_subrange.hpp>
Header <boost/algorithm/string.hpp>
Header <boost/algorithm/string_regex.hpp>

Misc Algorithms.

Marshall Clow

namespace boost {
  namespace algorithm {
    template<typename T> T identity_operation(std::multiplies< T >);
    template<typename T> T identity_operation(std::plus< T >);
    template<typename T, typename Integer> 
      boost::enable_if< boost::is_integral< Integer >, T >::type 
      power(T, Integer);
    template<typename T, typename Integer, typename Operation> 
      boost::enable_if< boost::is_integral< Integer >, T >::type 
      power(T, Integer, Operation);
  }
}

Clamp algorithm.

Marshall Clow

Suggested by olafvdspek in https://svn.boost.org/trac/boost/ticket/3215

namespace boost {
  namespace algorithm {
    template<typename T, typename Pred> 
      T const & clamp(T const &, 
                      typename boost::mpl::identity< T >::type const &, 
                      typename boost::mpl::identity< T >::type const &, Pred);
    template<typename T> 
      T const & clamp(const T &, 
                      typename boost::mpl::identity< T >::type const &, 
                      typename boost::mpl::identity< T >::type const &);
    template<typename InputIterator, typename OutputIterator> 
      OutputIterator 
      clamp_range(InputIterator first, InputIterator last, OutputIterator out, 
                  typename std::iterator_traits< InputIterator >::value_type const & lo, 
                  typename std::iterator_traits< InputIterator >::value_type const & hi);
    template<typename Range, typename OutputIterator> 
      boost::disable_if_c< boost::is_same< Range, OutputIterator >::value, OutputIterator >::type 
      clamp_range(const Range &, OutputIterator, 
                  typename std::iterator_traits< typename boost::range_iterator< const Range >::type >::value_type const &, 
                  typename std::iterator_traits< typename boost::range_iterator< const Range >::type >::value_type const &);
    template<typename InputIterator, typename OutputIterator, typename Pred> 
      OutputIterator 
      clamp_range(InputIterator first, InputIterator last, OutputIterator out, 
                  typename std::iterator_traits< InputIterator >::value_type const & lo, 
                  typename std::iterator_traits< InputIterator >::value_type const & hi, 
                  Pred p);
    template<typename Range, typename OutputIterator, typename Pred> 
      boost::disable_if_c< boost::is_same< Range, OutputIterator >::value, OutputIterator >::type 
      clamp_range(const Range &, OutputIterator, 
                  typename std::iterator_traits< typename boost::range_iterator< const Range >::type >::value_type const &, 
                  typename std::iterator_traits< typename boost::range_iterator< const Range >::type >::value_type const &, 
                  Pred);
  }
}

Test ranges to see if all elements match a value or predicate.

Marshall Clow

namespace boost {
  namespace algorithm {
    template<typename InputIterator, typename Predicate> 
      bool all_of(InputIterator, InputIterator, Predicate);
    template<typename Range, typename Predicate> 
      bool all_of(const Range &, Predicate);
    template<typename InputIterator, typename T> 
      bool all_of_equal(InputIterator, InputIterator, const T &);
    template<typename Range, typename T> 
      bool all_of_equal(const Range &, const T &);
  }
}

Test ranges to see if any elements match a value or predicate.

Marshall Clow

namespace boost {
  namespace algorithm {
    template<typename InputIterator, typename Predicate> 
      bool any_of(InputIterator, InputIterator, Predicate);
    template<typename Range, typename Predicate> 
      bool any_of(const Range &, Predicate);
    template<typename InputIterator, typename V> 
      bool any_of_equal(InputIterator, InputIterator, const V &);
    template<typename Range, typename V> 
      bool any_of_equal(const Range &, const V &);
  }
}

Copy a subset of a sequence to a new sequence.

Marshall Clow

namespace boost {
  namespace algorithm {
    template<typename InputIterator, typename OutputIterator, 
             typename Predicate> 
      OutputIterator 
      copy_if(InputIterator, InputIterator, OutputIterator, Predicate);
    template<typename Range, typename OutputIterator, typename Predicate> 
      OutputIterator copy_if(const Range &, OutputIterator, Predicate);
    template<typename InputIterator, typename OutputIterator, 
             typename Predicate> 
      std::pair< InputIterator, OutputIterator > 
      copy_while(InputIterator, InputIterator, OutputIterator, Predicate);
    template<typename Range, typename OutputIterator, typename Predicate> 
      std::pair< typename boost::range_iterator< const Range >::type, OutputIterator > 
      copy_while(const Range &, OutputIterator, Predicate);
    template<typename InputIterator, typename OutputIterator, 
             typename Predicate> 
      std::pair< InputIterator, OutputIterator > 
      copy_until(InputIterator, InputIterator, OutputIterator, Predicate);
    template<typename Range, typename OutputIterator, typename Predicate> 
      std::pair< typename boost::range_iterator< const Range >::type, OutputIterator > 
      copy_until(const Range &, OutputIterator, Predicate);
  }
}

Copy n items from one sequence to another.

Marshall Clow

namespace boost {
  namespace algorithm {
    template<typename InputIterator, typename Size, typename OutputIterator> 
      OutputIterator copy_n(InputIterator, Size, OutputIterator);
  }
}

Find the first element in a sequence that does not satisfy a predicate.

Marshall Clow

namespace boost {
  namespace algorithm {
    template<typename InputIterator, typename Predicate> 
      InputIterator find_if_not(InputIterator, InputIterator, Predicate);
    template<typename Range, typename Predicate> 
      boost::range_iterator< const Range >::type 
      find_if_not(const Range &, Predicate);
  }
}

Generate an increasing series.

Marshall Clow

namespace boost {
  namespace algorithm {
    template<typename ForwardIterator, typename T> 
      void iota(ForwardIterator, ForwardIterator, T);
    template<typename Range, typename T> void iota(Range &, T);
    template<typename OutputIterator, typename T> 
      OutputIterator iota_n(OutputIterator, T, std::size_t);
  }
}

Tell if a sequence is partitioned.

Marshall Clow

namespace boost {
  namespace algorithm {
    template<typename InputIterator, typename UnaryPredicate> 
      bool is_partitioned(InputIterator, InputIterator, UnaryPredicate);
    template<typename Range, typename UnaryPredicate> 
      bool is_partitioned(const Range &, UnaryPredicate);
  }
}
namespace boost {
  namespace algorithm {
    template<typename ForwardIterator1, typename ForwardIterator2, 
             typename BinaryPredicate> 
      bool is_permutation(ForwardIterator1, ForwardIterator1, 
                          ForwardIterator2, BinaryPredicate);
    template<typename ForwardIterator1, typename ForwardIterator2> 
      bool is_permutation(ForwardIterator1, ForwardIterator1, 
                          ForwardIterator2);
    template<typename Range, typename ForwardIterator> 
      bool is_permutation(const Range &, ForwardIterator);
    template<typename Range, typename ForwardIterator, 
             typename BinaryPredicate> 
      boost::disable_if_c< boost::is_same< Range, ForwardIterator >::value, bool >::type 
      is_permutation(const Range &, ForwardIterator, BinaryPredicate);
  }
}
namespace boost {
  namespace algorithm {
    template<typename ForwardIterator1, typename ForwardIterator2> 
      bool is_permutation(ForwardIterator1, ForwardIterator1, 
                          ForwardIterator2, ForwardIterator2);
    template<typename ForwardIterator1, typename ForwardIterator2, 
             typename BinaryPredicate> 
      bool is_permutation(ForwardIterator1, ForwardIterator1, 
                          ForwardIterator2, ForwardIterator2, 
                          BinaryPredicate);
  }
}
namespace boost {
  namespace algorithm {
    template<typename ForwardIterator, typename Pred> 
      ForwardIterator is_sorted_until(ForwardIterator, ForwardIterator, Pred);
    template<typename ForwardIterator> 
      ForwardIterator is_sorted_until(ForwardIterator, ForwardIterator);
    template<typename ForwardIterator, typename Pred> 
      bool is_sorted(ForwardIterator, ForwardIterator, Pred);
    template<typename ForwardIterator> 
      bool is_sorted(ForwardIterator, ForwardIterator);
    template<typename R, typename Pred> 
      boost::lazy_disable_if_c< boost::is_same< R, Pred >::value, typename boost::range_iterator< const R > >::type 
      is_sorted_until(const R &, Pred);
    template<typename R> 
      boost::range_iterator< const R >::type is_sorted_until(const R &);
    template<typename R, typename Pred> 
      boost::lazy_disable_if_c< boost::is_same< R, Pred >::value, boost::mpl::identity< bool > >::type 
      is_sorted(const R &, Pred);
    template<typename R> bool is_sorted(const R &);
    template<typename ForwardIterator> 
      bool is_increasing(ForwardIterator, ForwardIterator);
    template<typename R> bool is_increasing(const R &);
    template<typename ForwardIterator> 
      bool is_decreasing(ForwardIterator, ForwardIterator);
    template<typename R> bool is_decreasing(const R &);
    template<typename ForwardIterator> 
      bool is_strictly_increasing(ForwardIterator, ForwardIterator);
    template<typename R> bool is_strictly_increasing(const R &);
    template<typename ForwardIterator> 
      bool is_strictly_decreasing(ForwardIterator, ForwardIterator);
    template<typename R> bool is_strictly_decreasing(const R &);
  }
}

Test ranges to see if no elements match a value or predicate.

Marshall Clow

namespace boost {
  namespace algorithm {
    template<typename InputIterator, typename Predicate> 
      bool none_of(InputIterator, InputIterator, Predicate);
    template<typename Range, typename Predicate> 
      bool none_of(const Range &, Predicate);
    template<typename InputIterator, typename V> 
      bool none_of_equal(InputIterator, InputIterator, const V &);
    template<typename Range, typename V> 
      bool none_of_equal(const Range &, const V &);
  }
}

Test ranges to see if only one element matches a value or predicate.

Marshall Clow

namespace boost {
  namespace algorithm {
    template<typename InputIterator, typename Predicate> 
      bool one_of(InputIterator, InputIterator, Predicate);
    template<typename Range, typename Predicate> 
      bool one_of(const Range &, Predicate);
    template<typename InputIterator, typename V> 
      bool one_of_equal(InputIterator, InputIterator, const V &);
    template<typename Range, typename V> 
      bool one_of_equal(const Range &, const V &);
  }
}

Copy a subset of a sequence to a new sequence.

Marshall Clow

namespace boost {
  namespace algorithm {
    template<typename InputIterator, typename OutputIterator1, 
             typename OutputIterator2, typename UnaryPredicate> 
      std::pair< OutputIterator1, OutputIterator2 > 
      partition_copy(InputIterator, InputIterator, OutputIterator1, 
                     OutputIterator2, UnaryPredicate);
    template<typename Range, typename OutputIterator1, 
             typename OutputIterator2, typename UnaryPredicate> 
      std::pair< OutputIterator1, OutputIterator2 > 
      partition_copy(const Range &, OutputIterator1, OutputIterator2, 
                     UnaryPredicate);
  }
}

Find the partition point in a sequence.

Marshall Clow

namespace boost {
  namespace algorithm {
    template<typename ForwardIterator, typename Predicate> 
      ForwardIterator 
      partition_point(ForwardIterator, ForwardIterator, Predicate);
    template<typename Range, typename Predicate> 
      boost::range_iterator< Range >::type partition_point(Range &, Predicate);
  }
}

Test ranges to if they are equal.

Marshall Clow

namespace boost {
  namespace algorithm {
    template<typename InputIterator1, typename InputIterator2, 
             typename BinaryPredicate> 
      bool equal(InputIterator1, InputIterator1, InputIterator2, 
                 InputIterator2, BinaryPredicate);
    template<typename InputIterator1, typename InputIterator2> 
      bool equal(InputIterator1, InputIterator1, InputIterator2, 
                 InputIterator2);
  }
}

Find the first mismatched element in a sequence.

Marshall Clow

namespace boost {
  namespace algorithm {
    template<typename InputIterator1, typename InputIterator2, 
             typename BinaryPredicate> 
      std::pair< InputIterator1, InputIterator2 > 
      mismatch(InputIterator1, InputIterator1, InputIterator2, InputIterator2, 
               BinaryPredicate);
    template<typename InputIterator1, typename InputIterator2> 
      std::pair< InputIterator1, InputIterator2 > 
      mismatch(InputIterator1, InputIterator1, InputIterator2, InputIterator2);
  }
}
namespace boost {
  namespace algorithm {

    // iterator-based gather implementation 
    template<typename BidirectionalIterator, typename Pred> 
      std::pair< BidirectionalIterator, BidirectionalIterator > 
      gather(BidirectionalIterator first, BidirectionalIterator last, 
             BidirectionalIterator pivot, Pred pred);

    // range-based gather implementation 
    template<typename BidirectionalRange, typename Pred> 
      std::pair< typename boost::range_iterator< const BidirectionalRange >::type, typename boost::range_iterator< const BidirectionalRange >::type > 
      gather(const BidirectionalRange & range, 
             typename boost::range_iterator< const BidirectionalRange >::type pivot, 
             Pred pred);
  }
}

Convert sequence of integral types into a sequence of hexadecimal characters and back. Based on the MySQL functions HEX and UNHEX.

Marshall Clow

namespace boost {
  namespace algorithm {
    struct hex_decode_error;
    struct not_enough_input;
    struct non_hex_input;

    typedef boost::error_info< struct bad_char_, char > bad_char;
    template<typename InputIterator, typename OutputIterator> 
      unspecified hex(InputIterator, InputIterator, OutputIterator);
    template<typename InputIterator, typename OutputIterator> 
      unspecified hex_lower(InputIterator, InputIterator, OutputIterator);
    template<typename T, typename OutputIterator> 
      boost::enable_if< boost::is_integral< T >, OutputIterator >::type 
      hex(const T *, OutputIterator);
    template<typename T, typename OutputIterator> 
      boost::enable_if< boost::is_integral< T >, OutputIterator >::type 
      hex_lower(const T *, OutputIterator);
    template<typename Range, typename OutputIterator> 
      unspecified hex(const Range &, OutputIterator);
    template<typename Range, typename OutputIterator> 
      unspecified hex_lower(const Range &, OutputIterator);
    template<typename InputIterator, typename OutputIterator> 
      OutputIterator unhex(InputIterator, InputIterator, OutputIterator);
    template<typename T, typename OutputIterator> 
      OutputIterator unhex(const T *, OutputIterator);
    template<typename Range, typename OutputIterator> 
      OutputIterator unhex(const Range &, OutputIterator);
    template<typename String> String hex(const String &);
    template<typename String> String hex_lower(const String &);
    template<typename String> String unhex(const String &);
  }
}

Checks the input sequence on palindrome.

Alexander Zaitsev

namespace boost {
  namespace algorithm {
    template<typename BidirectionalIterator, typename Predicate> 
      bool is_palindrome(BidirectionalIterator, BidirectionalIterator, 
                         Predicate);
    template<typename BidirectionalIterator> 
      bool is_palindrome(BidirectionalIterator, BidirectionalIterator);
    template<typename R> bool is_palindrome(const R &);
    template<typename R, typename Predicate> 
      bool is_palindrome(const R &, Predicate);
    bool is_palindrome(const char *);
    template<typename Predicate> bool is_palindrome(const char *, Predicate);
  }
}
namespace boost {
  template<typename T> 
    tuple< T const &, T const & > minmax(T const & a, T const & b);
  template<typename T, typename BinaryPredicate> 
    tuple< T const &, T const & > 
    minmax(T const & a, T const & b, BinaryPredicate comp);
}
namespace boost {
  template<typename ForwardIter> 
    std::pair< ForwardIter, ForwardIter > 
    minmax_element(ForwardIter first, ForwardIter last);
  template<typename ForwardIter, typename BinaryPredicate> 
    std::pair< ForwardIter, ForwardIter > 
    minmax_element(ForwardIter first, ForwardIter last, BinaryPredicate comp);
  template<typename ForwardIter> 
    ForwardIter first_min_element(ForwardIter first, ForwardIter last);
  template<typename ForwardIter, typename BinaryPredicate> 
    ForwardIter first_min_element(ForwardIter first, ForwardIter last, 
                                  BinaryPredicate comp);
  template<typename ForwardIter> 
    ForwardIter last_min_element(ForwardIter first, ForwardIter last);
  template<typename ForwardIter, typename BinaryPredicate> 
    ForwardIter last_min_element(ForwardIter first, ForwardIter last, 
                                 BinaryPredicate comp);
  template<typename ForwardIter> 
    ForwardIter first_max_element(ForwardIter first, ForwardIter last);
  template<typename ForwardIter, typename BinaryPredicate> 
    ForwardIter first_max_element(ForwardIter first, ForwardIter last, 
                                  BinaryPredicate comp);
  template<typename ForwardIter> 
    ForwardIter last_max_element(ForwardIter first, ForwardIter last);
  template<typename ForwardIter, typename BinaryPredicate> 
    ForwardIter last_max_element(ForwardIter first, ForwardIter last, 
                                 BinaryPredicate comp);
  template<typename ForwardIter> 
    std::pair< ForwardIter, ForwardIter > 
    first_min_first_max_element(ForwardIter first, ForwardIter last);
  template<typename ForwardIter, typename BinaryPredicate> 
    std::pair< ForwardIter, ForwardIter > 
    first_min_first_max_element(ForwardIter first, ForwardIter last, 
                                BinaryPredicate comp);
  template<typename ForwardIter> 
    std::pair< ForwardIter, ForwardIter > 
    first_min_last_max_element(ForwardIter first, ForwardIter last);
  template<typename ForwardIter, typename BinaryPredicate> 
    std::pair< ForwardIter, ForwardIter > 
    first_min_last_max_element(ForwardIter first, ForwardIter last, 
                               BinaryPredicate comp);
  template<typename ForwardIter> 
    std::pair< ForwardIter, ForwardIter > 
    last_min_first_max_element(ForwardIter first, ForwardIter last);
  template<typename ForwardIter, typename BinaryPredicate> 
    std::pair< ForwardIter, ForwardIter > 
    last_min_first_max_element(ForwardIter first, ForwardIter last, 
                               BinaryPredicate comp);
  template<typename ForwardIter> 
    std::pair< ForwardIter, ForwardIter > 
    last_min_last_max_element(ForwardIter first, ForwardIter last);
  template<typename ForwardIter, typename BinaryPredicate> 
    std::pair< ForwardIter, ForwardIter > 
    last_min_last_max_element(ForwardIter first, ForwardIter last, 
                              BinaryPredicate comp);
}
namespace boost {
  namespace algorithm {
    template<typename patIter, typename traits = detail::BM_traits<patIter> > 
      class boyer_moore;
    template<typename patIter, typename corpusIter> 
      std::pair< corpusIter, corpusIter > 
      boyer_moore_search(corpusIter, corpusIter, patIter, patIter);
    template<typename PatternRange, typename corpusIter> 
      std::pair< corpusIter, corpusIter > 
      boyer_moore_search(corpusIter corpus_first, corpusIter corpus_last, 
                         const PatternRange & pattern);
    template<typename patIter, typename CorpusRange> 
      boost::disable_if_c< boost::is_same< CorpusRange, patIter >::value, std::pair< typename boost::range_iterator< CorpusRange >::type, typename boost::range_iterator< CorpusRange >::type > >::type 
      boyer_moore_search(CorpusRange & corpus, patIter pat_first, 
                         patIter pat_last);
    template<typename PatternRange, typename CorpusRange> 
      std::pair< typename boost::range_iterator< CorpusRange >::type, typename boost::range_iterator< CorpusRange >::type > 
      boyer_moore_search(CorpusRange & corpus, const PatternRange & pattern);
    template<typename Range> 
      boost::algorithm::boyer_moore< typename boost::range_iterator< const Range >::type > 
      make_boyer_moore(const Range & r);
    template<typename Range> 
      boost::algorithm::boyer_moore< typename boost::range_iterator< Range >::type > 
      make_boyer_moore(Range & r);
  }
}
namespace boost {
  namespace algorithm {
    template<typename patIter, typename traits = detail::BM_traits<patIter> > 
      class boyer_moore_horspool;
    template<typename patIter, typename corpusIter> 
      std::pair< corpusIter, corpusIter > 
      boyer_moore_horspool_search(corpusIter, corpusIter, patIter, patIter);
    template<typename PatternRange, typename corpusIter> 
      std::pair< corpusIter, corpusIter > 
      boyer_moore_horspool_search(corpusIter corpus_first, 
                                  corpusIter corpus_last, 
                                  const PatternRange & pattern);
    template<typename patIter, typename CorpusRange> 
      boost::disable_if_c< boost::is_same< CorpusRange, patIter >::value, std::pair< typename boost::range_iterator< CorpusRange >::type, typename boost::range_iterator< CorpusRange >::type > >::type 
      boyer_moore_horspool_search(CorpusRange & corpus, patIter pat_first, 
                                  patIter pat_last);
    template<typename PatternRange, typename CorpusRange> 
      std::pair< typename boost::range_iterator< CorpusRange >::type, typename boost::range_iterator< CorpusRange >::type > 
      boyer_moore_horspool_search(CorpusRange & corpus, 
                                  const PatternRange & pattern);
    template<typename Range> 
      boost::algorithm::boyer_moore_horspool< typename boost::range_iterator< const Range >::type > 
      make_boyer_moore_horspool(const Range & r);
    template<typename Range> 
      boost::algorithm::boyer_moore_horspool< typename boost::range_iterator< Range >::type > 
      make_boyer_moore_horspool(Range & r);
  }
}
namespace boost {
  namespace algorithm {
    template<typename patIter> class knuth_morris_pratt;
    template<typename patIter, typename corpusIter> 
      std::pair< corpusIter, corpusIter > 
      knuth_morris_pratt_search(corpusIter, corpusIter, patIter, patIter);
    template<typename PatternRange, typename corpusIter> 
      std::pair< corpusIter, corpusIter > 
      knuth_morris_pratt_search(corpusIter corpus_first, 
                                corpusIter corpus_last, 
                                const PatternRange & pattern);
    template<typename patIter, typename CorpusRange> 
      boost::disable_if_c< boost::is_same< CorpusRange, patIter >::value, std::pair< typename boost::range_iterator< CorpusRange >::type, typename boost::range_iterator< CorpusRange >::type > >::type 
      knuth_morris_pratt_search(CorpusRange & corpus, patIter pat_first, 
                                patIter pat_last);
    template<typename PatternRange, typename CorpusRange> 
      std::pair< typename boost::range_iterator< CorpusRange >::type, typename boost::range_iterator< CorpusRange >::type > 
      knuth_morris_pratt_search(CorpusRange & corpus, 
                                const PatternRange & pattern);
    template<typename Range> 
      boost::algorithm::knuth_morris_pratt< typename boost::range_iterator< const Range >::type > 
      make_knuth_morris_pratt(const Range & r);
    template<typename Range> 
      boost::algorithm::knuth_morris_pratt< typename boost::range_iterator< Range >::type > 
      make_knuth_morris_pratt(Range & r);
  }
}

Sort a subrange.

Marshall Clow

Suggested by Sean Parent in his CppCon 2015 keynote

namespace boost {
  namespace algorithm {
    template<typename Iterator, typename Pred> 
      void sort_subrange(Iterator first, Iterator last, Iterator sub_first, 
                         Iterator sub_last, Pred p);
    template<typename Iterator> 
      void sort_subrange(Iterator first, Iterator last, Iterator sub_first, 
                         Iterator sub_last);
    template<typename Iterator, typename Pred> 
      void partition_subrange(Iterator first, Iterator last, 
                              Iterator sub_first, Iterator sub_last, Pred p);
    template<typename Iterator> 
      void partition_subrange(Iterator first, Iterator last, 
                              Iterator sub_first, Iterator sub_last);
  }
}

Cumulative include for string_algo library

Cumulative include for string_algo library. In addition to string.hpp contains also regex-related stuff.


PrevUpHomeNext