<?xml version="1.0" encoding="utf-8" ?>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
<meta name="generator" content="Docutils 0.3.10: http://docutils.sourceforge.net/" />
<title>Range Library Core</title>
<meta name="author" content="Thorsten Ottosen" />
<meta name="date" content="2005-09-08" />
<style type="text/css">

/*
:Author: David Goodger
:Contact: goodger@users.sourceforge.net
:Date: $Date: 2005-09-25 17:49:54 +0200 (Sun, 25 Sep 2005) $
:Revision: $Revision: 3901 $
:Copyright: This stylesheet has been placed in the public domain.

Default cascading style sheet for the HTML output of Docutils.

See http://docutils.sf.net/docs/howto/html-stylesheets.html for how to
customize this style sheet.
*/

/* "! important" is used here to override other ``margin-top`` and
   ``margin-bottom`` styles that are later in the stylesheet or 
   more specific.  See http://www.w3.org/TR/CSS1#the-cascade */
.first {
  margin-top: 0 ! important }

.last, .with-subtitle {
  margin-bottom: 0 ! important }

.hidden {
  display: none }

a.toc-backref {
  text-decoration: none ;
  color: black }

blockquote.epigraph {
  margin: 2em 5em ; }

dl.docutils dd {
  margin-bottom: 0.5em }

/* Uncomment (and remove this text!) to get bold-faced definition list terms
dl.docutils dt {
  font-weight: bold }
*/

div.abstract {
  margin: 2em 5em }

div.abstract p.topic-title {
  font-weight: bold ;
  text-align: center }

div.admonition, div.attention, div.caution, div.danger, div.error,
div.hint, div.important, div.note, div.tip, div.warning {
  margin: 2em ;
  border: medium outset ;
  padding: 1em }

div.admonition p.admonition-title, div.hint p.admonition-title,
div.important p.admonition-title, div.note p.admonition-title,
div.tip p.admonition-title {
  font-weight: bold ;
  font-family: sans-serif }

div.attention p.admonition-title, div.caution p.admonition-title,
div.danger p.admonition-title, div.error p.admonition-title,
div.warning p.admonition-title {
  color: red ;
  font-weight: bold ;
  font-family: sans-serif }

/* Uncomment (and remove this text!) to get reduced vertical space in
   compound paragraphs.
div.compound .compound-first, div.compound .compound-middle {
  margin-bottom: 0.5em }

div.compound .compound-last, div.compound .compound-middle {
  margin-top: 0.5em }
*/

div.dedication {
  margin: 2em 5em ;
  text-align: center ;
  font-style: italic }

div.dedication p.topic-title {
  font-weight: bold ;
  font-style: normal }

div.figure {
  margin-left: 2em }

div.footer, div.header {
  clear: both;
  font-size: smaller }

div.line-block {
  display: block ;
  margin-top: 1em ;
  margin-bottom: 1em }

div.line-block div.line-block {
  margin-top: 0 ;
  margin-bottom: 0 ;
  margin-left: 1.5em }

div.sidebar {
  margin-left: 1em ;
  border: medium outset ;
  padding: 1em ;
  background-color: #ffffee ;
  width: 40% ;
  float: right ;
  clear: right }

div.sidebar p.rubric {
  font-family: sans-serif ;
  font-size: medium }

div.system-messages {
  margin: 5em }

div.system-messages h1 {
  color: red }

div.system-message {
  border: medium outset ;
  padding: 1em }

div.system-message p.system-message-title {
  color: red ;
  font-weight: bold }

div.topic {
  margin: 2em }

h1.section-subtitle, h2.section-subtitle, h3.section-subtitle,
h4.section-subtitle, h5.section-subtitle, h6.section-subtitle {
  margin-top: 0.4em }

h1.title {
  text-align: center }

h2.subtitle {
  text-align: center }

hr.docutils {
  width: 75% }

img.align-left {
  clear: left }

img.align-right {
  clear: right }

img.borderless {
  border: 0 }

ol.simple, ul.simple {
  margin-bottom: 1em }

ol.arabic {
  list-style: decimal }

ol.loweralpha {
  list-style: lower-alpha }

ol.upperalpha {
  list-style: upper-alpha }

ol.lowerroman {
  list-style: lower-roman }

ol.upperroman {
  list-style: upper-roman }

p.attribution {
  text-align: right ;
  margin-left: 50% }

p.caption {
  font-style: italic }

p.credits {
  font-style: italic ;
  font-size: smaller }

p.label {
  white-space: nowrap }

p.rubric {
  font-weight: bold ;
  font-size: larger ;
  color: maroon ;
  text-align: center }

p.sidebar-title {
  font-family: sans-serif ;
  font-weight: bold ;
  font-size: larger }

p.sidebar-subtitle {
  font-family: sans-serif ;
  font-weight: bold }

p.topic-title {
  font-weight: bold }

pre.address {
  margin-bottom: 0 ;
  margin-top: 0 ;
  font-family: serif ;
  font-size: 100% }

pre.line-block {
  font-family: serif ;
  font-size: 100% }

pre.literal-block, pre.doctest-block {
  margin-left: 2em ;
  margin-right: 2em ;
  background-color: #eeeeee }

span.classifier {
  font-family: sans-serif ;
  font-style: oblique }

span.classifier-delimiter {
  font-family: sans-serif ;
  font-weight: bold }

span.interpreted {
  font-family: sans-serif }

span.option {
  white-space: nowrap }

span.pre {
  white-space: pre }

span.problematic {
  color: red }

span.section-subtitle {
  /* font-size relative to parent (h1..h6 element) */
  font-size: 80% }

table.citation {
  border-left: solid thin gray }

table.docinfo {
  margin: 2em 4em }

table.docutils {
  margin-top: 0.5em ;
  margin-bottom: 0.5em }

table.footnote {
  border-left: solid thin black }

table.docutils td, table.docutils th,
table.docinfo td, table.docinfo th {
  padding-left: 0.5em ;
  padding-right: 0.5em ;
  vertical-align: top }

table.docutils th.field-name, table.docinfo th.docinfo-name {
  font-weight: bold ;
  text-align: left ;
  white-space: nowrap ;
  padding-left: 0 }

h1 tt.docutils, h2 tt.docutils, h3 tt.docutils,
h4 tt.docutils, h5 tt.docutils, h6 tt.docutils {
  font-size: 100% }

tt.docutils {
  background-color: #eeeeee }

ul.auto-toc {
  list-style-type: none }

</style>
</head>
<body>
<div class="document" id="range-library-core">
<h1 class="title">Range Library Core</h1>
<table class="docinfo" frame="void" rules="none">
<col class="docinfo-name" />
<col class="docinfo-content" />
<tbody valign="top">
<tr><th class="docinfo-name">Author:</th>
<td>Thorsten Ottosen</td></tr>
<tr><th class="docinfo-name">Contact:</th>
<td><a class="first last reference" href="mailto:tottosen&#64;dezide.com">tottosen&#64;dezide.com</a></td></tr>
<tr class="field"><th class="docinfo-name">organizations:</th><td class="field-body"><a class="reference" href="http://www.dezide.com">Dezide Aps</a></td>
</tr>
<tr><th class="docinfo-name">Date:</th>
<td>2006-09-08</td></tr>
<tr class="field"><th class="docinfo-name">Number:</th><td class="field-body">WG21/N2068 J16/06-0138 (revision of WG21/<a class="reference" href="http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2005/n1871.html">N1871</a> and J16/05-0131)</td>
</tr>
<tr class="field"><th class="docinfo-name">Working Group:</th><td class="field-body">Evolution</td>
</tr>
</tbody>
</table>
<div class="abstract topic">
<p class="topic-title first">Abstract</p>
<p>This paper proposes the addition of ranges
to the C++ standard library to reduce the syntactic burden
on programmers. The focus is on the minimal core features that
enables enhanced algorithm interfaces.</p>
</div>
<div class="contents topic">
<p class="topic-title first"><a id="table-of-contents" name="table-of-contents">Table of Contents</a></p>
<ul class="simple">
<li><a class="reference" href="#introduction" id="id1" name="id1">Introduction</a><ul>
<li><a class="reference" href="#what-is-a-range" id="id2" name="id2">What is a range?</a></li>
<li><a class="reference" href="#advantages" id="id3" name="id3">Advantages</a></li>
</ul>
</li>
<li><a class="reference" href="#wording" id="id4" name="id4">Wording</a><ul>
<li><a class="reference" href="#header-iterator-synopsis" id="id5" name="id5">24.2 Header &lt;iterator&gt; synopsis</a></li>
<li><a class="reference" href="#range-primitives" id="id6" name="id6">24.6 Range primitives</a><ul>
<li><a class="reference" href="#range-operations" id="id7" name="id7">24.6.1 Range operations</a></li>
<li><a class="reference" href="#range-traits" id="id8" name="id8">24.6.2 Range traits</a></li>
<li><a class="reference" href="#range-utilities" id="id9" name="id9">24.6.3 Range utilities</a></li>
</ul>
</li>
</ul>
</li>
<li><a class="reference" href="#acknowledgements" id="id10" name="id10">Acknowledgements</a></li>
</ul>
</div>
<!-- section-numbering: -->
<div class="section">
<h1><a class="toc-backref" href="#id1" id="introduction" name="introduction">Introduction</a></h1>
<div class="section">
<h2><a class="toc-backref" href="#id2" id="what-is-a-range" name="what-is-a-range">What is a range?</a></h2>
<p>A range is simply an encapsulation
of two iterators. The term range is due to paragraph 24.1/7 from the C++ standard:</p>
<blockquote>
Most of the library's algorithmic templates that operate on data structures have interfaces that use ranges. 
A range is a pair of iterators that designate the beginning and end of the computation. 
A range <tt class="docutils literal"><span class="pre">[i,</span> <span class="pre">i)</span></tt> is an empty range; in general, a range <tt class="docutils literal"><span class="pre">[i,</span> <span class="pre">j)</span></tt> refers to
the elements in the data structure starting with the one pointed to by <tt class="docutils literal"><span class="pre">i</span></tt>
and up to but not including the one pointed to by <tt class="docutils literal"><span class="pre">j</span></tt>. Range <tt class="docutils literal"><span class="pre">[i,</span> <span class="pre">j)</span></tt> is valid if
and only if <tt class="docutils literal"><span class="pre">j</span></tt> is reachable from <tt class="docutils literal"><span class="pre">i</span></tt>. 
The result of the application of functions in the library to invalid ranges is undefined.</blockquote>
</div>
<div class="section">
<h2><a class="toc-backref" href="#id3" id="advantages" name="advantages">Advantages</a></h2>
<p>Even though standard algorithms are specified in terms of iterator ranges,
they are still somewhat clumsy to use. By combining the two iterators into
one object, we can achieve great benefits. This proposal 
will give standard C++</p>
<blockquote>
<ol class="arabic simple">
<li>a drastic reduction in syntactic overhead,</li>
</ol>
</blockquote>
<!--  -->
<blockquote>
<ol class="arabic simple" start="2">
<li>an infrastructure for range-based algorithms
(which can also be used for the new <tt class="docutils literal"><span class="pre">for</span></tt>-loop (see <a class="reference" href="http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2005/n1868.html">n1868</a> and <a class="reference" href="http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2006/n1961.html">n1961</a>)),</li>
</ol>
</blockquote>
<!--  -->
<blockquote>
<ol class="arabic simple" start="3">
<li>a new concise idiomatic use of algorithms and loops,</li>
</ol>
</blockquote>
<!--  -->
<blockquote>
<ol class="arabic simple" start="4">
<li>safer use of built-in arrays.</li>
</ol>
</blockquote>
<p>For more discussion, please refer to <a class="reference" href="http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2005/n1871.html">n1871</a>.</p>
<p>The new string algorithms in <a class="reference" href="http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2006/n2059.html">n2059</a> builds on the core range
primitives from this paper and this library component can thus 
be seen as a prerequisite for the string algorithms.</p>
<p>Each numbered section below describes a new section for the standard or 
modifications to an existing section.  Comments are written in bold and 
are not part of the wording</p>
</div>
</div>
<div class="section">
<h1><a class="toc-backref" href="#id4" id="wording" name="wording">Wording</a></h1>
<div class="section">
<h2><a class="toc-backref" href="#id5" id="header-iterator-synopsis" name="header-iterator-synopsis">24.2 Header &lt;iterator&gt; synopsis</a></h2>
<p><strong>Add the following to the end of the synopsis</strong>:</p>
<pre class="literal-block">
template&lt; class Range &gt;
auto range_begin( Range&amp;&amp; r ) -&gt; decltype( r.begin() );

template&lt; class Iterator &gt;
Iterator range_begin( const pair&lt;Iterator,Iterator&gt;&amp; p ) ;

template&lt; class T, size_t N &gt;
T* range_begin( T (&amp;array)[N] ) 

template&lt; class Range &gt;
auto begin( Range&amp;&amp; r ) -&gt; decltype( range_begin(r) );

template&lt; class Range &gt;
auto range_end( Range&amp;&amp; r ) -&gt; decltype( r.end() );

template&lt; class Iterator &gt;
Iterator range_end( const pair&lt;Iterator,Iterator&gt;&amp; p );

template&lt; class T, size_t N &gt;
T* range_end( T (&amp;array)[N] );

template&lt; class Range &gt;
auto end( Range&amp;&amp; r ) -&gt; decltype( range_end(r) );

template&lt; class Range &gt;
struct range_iterator; 

template&lt; class BidirectionalRange &gt;
struct range_reverse_iterator;

template&lt; class Range &gt;
struct range_value;

template&lt; class Range &gt;
struct range_reference;

template&lt; class Range &gt;
struct range_pointer;
 
template&lt; class Range &gt;
struct range_difference;

template&lt; class Range &gt;
struct range_category;

template&lt; class Range &gt;
bool empty( const Range&amp; r );

template&lt; class RandomAccessRange &gt;
typename range_difference&lt;RandomAccessRange&gt;::type 
size( const RandomAccessRange&amp; r );

template&lt; class BidirectionalRange &gt;
typename range_reverse_iterator&lt;BidirectionalRange&gt;::type 
rbegin( BidirectionalRange&amp;&amp; r );

template&lt; class BidirectionalRange &gt;
typename range_reverse_iterator&lt;BidirectionalRange&gt;::type
rend( BidirectionalRange&amp;&amp; r );

template&lt; class Range &gt;
typename range_iterator&lt;const Range&gt;::type 
const_begin( const Range&amp; r );

template&lt; class Range &gt;
typename range_iterator&lt;const Range&gt;::type 
const_end( const Range&amp; r );

template&lt; class BidirectionalRange &gt;
typename range_reverse_iterator&lt;const BidirectionalRange&gt;::type 
const_rbegin( const BidirectionalRange&amp; r );

template&lt; class BidirectionalRange &gt;
typename range_reverse_iterator&lt;const BidirectionalRange&gt;::type 
const_rend( const BidirectionalRange&amp; r );

template&lt; class Iterator &gt;
class range;

template&lt; class Range &gt;
class sub_range : public range&lt; typename range_iterator&lt;Range&gt;::type &gt;;

// stream output
template&lt; class Iterator, class T, class Traits &gt;
std::basic_ostream&lt;T,Traits&gt;&amp; 
operator&lt;&lt;( std::basic_ostream&lt;T,Traits&gt;&amp; Os,
            const range&lt;Iterator&gt;&amp; r );

// comparison
template&lt; class Iterator, class Iterator2 &gt;
bool operator==( const range&lt;Iterator&gt;&amp; l, const range&lt;Iterator2&gt;&amp; r );

template&lt; class Iterator, class Range &gt;
bool operator==( const range&lt;Iterator&gt;&amp; l, const Range&amp; r );

template&lt; class Iterator, class Range &gt;
bool operator==( const Range&amp; l, const range&lt;Iterator&gt;&amp; r );

template&lt; class Iterator, class Iterator2 &gt;
bool operator!=( const range&lt;Iterator&gt;&amp; l, const range&lt;Iterator2&gt;&amp; r );

template&lt; class Iterator, class Range &gt;
bool operator!=( const range&lt;Iterator&gt;&amp; l, const Range&amp; r );

template&lt; class Iterator, class Range &gt;
bool operator!=( const Range&amp; l, const range&lt;Iterator&gt;&amp; r );

template&lt; class Iterator, class Iterator2 &gt;
bool operator&lt;( const range&lt;Iterator&gt;&amp; l, const range&lt;Iterator2&gt;&amp; r );

template&lt; class Iterator, class Range &gt;
bool operator&lt;( const range&lt;Iterator&gt;&amp; l, const Range&amp; r );

template&lt; class Iterator, class Range &gt;
bool operator&lt;( const Range&amp; l, const range&lt;Iterator&gt;&amp; r );

template&lt; class Range, class Range2 &gt;
bool operator==( const sub_range&lt;Range&gt;&amp; l, const sub_range&lt;Range2&gt;&amp; r );

template&lt; class Range, class Range2 &gt;
bool operator!=( const sub_range&lt;Range&gt;&amp; l, const sub_range&lt;Range2&gt;&amp; r )

template&lt; class Range, class Range2 &gt;
bool operator&lt;( const sub_range&lt;Range&gt;&amp; l, const sub_range&lt;Range2&gt;&amp; r );

// external construction
template&lt; class Iterator &gt;
range&lt;Iterator&gt;
make_range( const Iterator&amp; begin, const Iterator&amp; end );
   
template&lt; class Range &gt;
range&lt;typename range_iterator&lt;Range&gt;::type&gt; 
make_range( Range&amp;&amp; r );

template&lt; class Range &gt;
range&lt;typename range_iterator&lt;Range&gt;::type&gt; 
make_range( Range&amp;&amp; r, typename range_difference&lt;Range&gt;::type advance_begin,
                       typename range_difference&lt;Range&gt;::type advance_end );
           
template&lt; class CopyableRange, class Range &gt;      
CopyableRange copy_range( const Range&amp; r );

template&lt; class ForwardRange &gt;
typename range_difference&lt;ForwardRange&gt;::type
distance( const ForwardRange&amp; r );
</pre>
</div>
<div class="section">
<h2><a class="toc-backref" href="#id6" id="range-primitives" name="range-primitives">24.6 Range primitives</a></h2>
<p><strong>Add the following new section</strong>:</p>
<p>To support ranges and range-based algorithms, the library provides 
free-standing functions that enable the range abstraction 
as well as several utilities.</p>
<p>A type <tt class="docutils literal"><span class="pre">T</span></tt> conforms to a range concept if the 
free-standing functions <tt class="docutils literal"><span class="pre">range_begin(T&amp;)</span></tt> and <tt class="docutils literal"><span class="pre">range_begin(T&amp;)</span></tt> have been defined 
in the namespace of <tt class="docutils literal"><span class="pre">T</span></tt> or if <tt class="docutils literal"><span class="pre">T</span></tt> has member functions named <tt class="docutils literal"><span class="pre">begin()</span></tt> and <tt class="docutils literal"><span class="pre">end()</span></tt>.
Furthermore, built-in arrays conforms to the range concept.
All these functions must return iterators in amortized constant time,
and the type of these iterators may vary with the constness 
of the range object. If the iterators of a range are mutable, we say the range is <em>mutable</em>, and 
if the iterators of a range are constant, we say the range is <em>constant</em>.</p>
<p>Each possible category of the associated iterator type of a range leads to a range category;
we therefore have the concept of <em>input ranges</em>, <em>forward ranges</em>, 
<em>bidirectional ranges</em> and <em>random access ranges</em>. There is no notion of an 
<em>output range</em>. A range is <em>singular</em> if any of its associated 
iterators are singular.</p>
<p>If a range <tt class="docutils literal"><span class="pre">T</span></tt> owns its associated values (like containers do) and has a 
deep-copy constructor that takes two iterator parameters, <tt class="docutils literal"><span class="pre">T</span></tt> is called 
a <em>copyable range</em>.</p>
<div class="section">
<h3><a class="toc-backref" href="#id7" id="range-operations" name="range-operations">24.6.1 Range operations</a></h3>
<p>The functions <tt class="docutils literal"><span class="pre">range_begin()</span></tt> and <tt class="docutils literal"><span class="pre">range_end()</span></tt> are intended to be 
overloaded for a user-defined type <tt class="docutils literal"><span class="pre">T</span></tt> in the namespace of <tt class="docutils literal"><span class="pre">T</span></tt>.</p>
<p>The functions <tt class="docutils literal"><span class="pre">begin()</span></tt> and <tt class="docutils literal"><span class="pre">end()</span></tt> are intended to be called 
qualified with the <tt class="docutils literal"><span class="pre">std</span></tt> namespace, and they are always called qualified 
within the standard library.  From these two functions the call to 
<tt class="docutils literal"><span class="pre">range_begin()</span></tt> and <tt class="docutils literal"><span class="pre">range_end()</span></tt>, respectively, is without namespace 
qualification to enable argument dependent lookup.</p>
<p><tt class="docutils literal"><span class="pre">template&lt;</span> <span class="pre">class</span> <span class="pre">Range</span> <span class="pre">&gt;</span> <span class="pre">auto</span> <span class="pre">range_begin(</span> <span class="pre">Range&amp;&amp;</span> <span class="pre">r</span> <span class="pre">)</span> <span class="pre">-&gt;</span> <span class="pre">decltype(</span> <span class="pre">r.begin()</span> <span class="pre">);</span></tt></p>
<ul class="simple">
<li><em>Returns</em>: <tt class="docutils literal"><span class="pre">r.begin()</span></tt></li>
</ul>
<p><tt class="docutils literal"><span class="pre">template&lt;</span> <span class="pre">class</span> <span class="pre">Iterator</span> <span class="pre">&gt;</span>
<span class="pre">Iterator</span> <span class="pre">range_begin(</span> <span class="pre">const</span> <span class="pre">pair&lt;Iterator,Iterator&gt;&amp;</span> <span class="pre">p</span> <span class="pre">);</span></tt></p>
<ul class="simple">
<li><em>Returns</em>: <tt class="docutils literal"><span class="pre">p.first</span></tt></li>
</ul>
<p><tt class="docutils literal"><span class="pre">template&lt;</span> <span class="pre">class</span> <span class="pre">T,</span> <span class="pre">size_t</span> <span class="pre">N</span> <span class="pre">&gt;</span>
<span class="pre">T*</span> <span class="pre">range_begin(</span> <span class="pre">T</span> <span class="pre">(&amp;array)[N]</span> <span class="pre">)</span></tt></p>
<ul class="simple">
<li><em>Returns</em>: <tt class="docutils literal"><span class="pre">array</span></tt></li>
</ul>
<p><tt class="docutils literal"><span class="pre">template&lt;</span> <span class="pre">class</span> <span class="pre">Range</span> <span class="pre">&gt;</span>
<span class="pre">auto</span> <span class="pre">begin(</span> <span class="pre">Range&amp;&amp;</span> <span class="pre">r</span> <span class="pre">)</span> <span class="pre">-&gt;</span> <span class="pre">decltype(</span> <span class="pre">range_begin(r)</span> <span class="pre">);</span></tt></p>
<ul class="simple">
<li><em>Returns</em>: <tt class="docutils literal"><span class="pre">range_begin(r)</span></tt></li>
</ul>
<p><tt class="docutils literal"><span class="pre">template&lt;</span> <span class="pre">class</span> <span class="pre">Range</span> <span class="pre">&gt;</span>
<span class="pre">auto</span> <span class="pre">range_end(</span> <span class="pre">Range&amp;&amp;</span> <span class="pre">r</span> <span class="pre">)</span> <span class="pre">-&gt;</span> <span class="pre">decltype(</span> <span class="pre">r.end()</span> <span class="pre">);</span></tt></p>
<ul class="simple">
<li><em>Returns</em>: <tt class="docutils literal"><span class="pre">r.end()</span></tt></li>
</ul>
<p><tt class="docutils literal"><span class="pre">template&lt;</span> <span class="pre">class</span> <span class="pre">Iterator</span> <span class="pre">&gt;</span>
<span class="pre">Iterator</span> <span class="pre">range_end(</span> <span class="pre">const</span> <span class="pre">pair&lt;Iterator,Iterator&gt;&amp;</span> <span class="pre">p</span> <span class="pre">);</span></tt></p>
<ul class="simple">
<li><em>Returns</em>: <tt class="docutils literal"><span class="pre">p.second</span></tt></li>
</ul>
<p><tt class="docutils literal"><span class="pre">template&lt;</span> <span class="pre">class</span> <span class="pre">T,</span> <span class="pre">size_t</span> <span class="pre">N</span> <span class="pre">&gt;</span>
<span class="pre">T*</span> <span class="pre">range_end(</span> <span class="pre">T</span> <span class="pre">(&amp;array)[N]</span> <span class="pre">);</span></tt></p>
<ul class="simple">
<li><em>Returns</em>: <tt class="docutils literal"><span class="pre">array</span> <span class="pre">+</span> <span class="pre">N</span></tt></li>
</ul>
<p><tt class="docutils literal"><span class="pre">template&lt;</span> <span class="pre">class</span> <span class="pre">Range</span> <span class="pre">&gt;</span>
<span class="pre">auto</span> <span class="pre">end(</span> <span class="pre">Range&amp;&amp;</span> <span class="pre">r</span> <span class="pre">)</span> <span class="pre">-&gt;</span> <span class="pre">decltype(</span> <span class="pre">range_end(r)</span> <span class="pre">);</span></tt></p>
<ul class="simple">
<li><em>Returns</em>: <tt class="docutils literal"><span class="pre">range_end(r)</span></tt></li>
</ul>
<p><tt class="docutils literal"><span class="pre">template&lt;</span> <span class="pre">class</span> <span class="pre">RandomAccessRange</span> <span class="pre">&gt;</span>
<span class="pre">typename</span> <span class="pre">range_difference&lt;RandomAccessRange&gt;::type</span> 
<span class="pre">size(</span> <span class="pre">const</span> <span class="pre">RandomAccessRange&amp;</span> <span class="pre">r</span> <span class="pre">);</span></tt></p>
<ul class="simple">
<li><em>Returns</em>: <tt class="docutils literal"><span class="pre">std::end(r)</span> <span class="pre">-</span> <span class="pre">std::begin(r)</span></tt></li>
</ul>
<p><tt class="docutils literal"><span class="pre">template&lt;</span> <span class="pre">class</span> <span class="pre">BidirectionalRange</span> <span class="pre">&gt;</span>
<span class="pre">typename</span> <span class="pre">range_reverse_iterator&lt;BidirectionalRange&gt;::type</span> 
<span class="pre">rbegin(</span> <span class="pre">BidirectionalRange&amp;&amp;</span> <span class="pre">r</span> <span class="pre">);</span></tt></p>
<ul class="simple">
<li><em>Returns</em>: <tt class="docutils literal"><span class="pre">typename</span> <span class="pre">range_reverse_iterator&lt;BidirectionalRange&gt;::type(std::end(r))</span></tt></li>
</ul>
<p><tt class="docutils literal"><span class="pre">template&lt;</span> <span class="pre">class</span> <span class="pre">BidirectionalRange</span> <span class="pre">&gt;</span>
<span class="pre">typename</span> <span class="pre">range_reverse_iterator&lt;BidirectionalRange&gt;::type</span>
<span class="pre">rend(</span> <span class="pre">BidirectionalRange&amp;&amp;</span> <span class="pre">r</span> <span class="pre">);</span></tt></p>
<ul class="simple">
<li><em>Returns</em>: <tt class="docutils literal"><span class="pre">typename</span> <span class="pre">range_reverse_iterator&lt;BidirectionalRange&gt;::type(std::begin(r))</span></tt></li>
</ul>
<p><tt class="docutils literal"><span class="pre">template&lt;</span> <span class="pre">class</span> <span class="pre">Range</span> <span class="pre">&gt;</span>
<span class="pre">typename</span> <span class="pre">range_iterator&lt;const</span> <span class="pre">Range&gt;::type</span> 
<span class="pre">const_begin(</span> <span class="pre">const</span> <span class="pre">Range&amp;</span> <span class="pre">r</span> <span class="pre">);</span></tt></p>
<ul class="simple">
<li><em>Returns</em>: <tt class="docutils literal"><span class="pre">std::begin(r)</span></tt></li>
</ul>
<p><tt class="docutils literal"><span class="pre">template&lt;</span> <span class="pre">class</span> <span class="pre">Range</span> <span class="pre">&gt;</span>
<span class="pre">typename</span> <span class="pre">range_iterator&lt;const</span> <span class="pre">Range&gt;::type</span> 
<span class="pre">const_end(</span> <span class="pre">const</span> <span class="pre">Range&amp;</span> <span class="pre">r</span> <span class="pre">);</span></tt></p>
<ul class="simple">
<li><em>Returns</em>: <tt class="docutils literal"><span class="pre">std::end(r)</span></tt></li>
</ul>
<p><tt class="docutils literal"><span class="pre">template&lt;</span> <span class="pre">class</span> <span class="pre">BidirectionalRange</span> <span class="pre">&gt;</span>
<span class="pre">typename</span> <span class="pre">range_reverse_iterator&lt;const</span> <span class="pre">BidirectionalRange&gt;::type</span> 
<span class="pre">const_rbegin(</span> <span class="pre">const</span> <span class="pre">BidirectionalRange&amp;</span> <span class="pre">r</span> <span class="pre">);</span></tt></p>
<ul class="simple">
<li><em>Returns</em>: <tt class="docutils literal"><span class="pre">std::rbegin(r)</span></tt></li>
</ul>
<p><tt class="docutils literal"><span class="pre">template&lt;</span> <span class="pre">class</span> <span class="pre">BidirectionalRange</span> <span class="pre">&gt;</span>
<span class="pre">typename</span> <span class="pre">range_reverse_iterator&lt;const</span> <span class="pre">BidirectionalRange&gt;::type</span> 
<span class="pre">const_rend(</span> <span class="pre">const</span> <span class="pre">BidirectionalRange&amp;</span> <span class="pre">r</span> <span class="pre">);</span></tt></p>
<ul class="simple">
<li><em>Returns</em>: <tt class="docutils literal"><span class="pre">std::rend(r)</span></tt></li>
</ul>
</div>
<div class="section">
<h3><a class="toc-backref" href="#id8" id="range-traits" name="range-traits">24.6.2 Range traits</a></h3>
<p>For convenience the type and properties of an associated iterator type 
of a range can be queried by range traits. Each trait is a TransformationTrait
and so define a nested type called <tt class="docutils literal"><span class="pre">type</span></tt>.</p>
<p><tt class="docutils literal"><span class="pre">template&lt;</span> <span class="pre">class</span> <span class="pre">Range</span> <span class="pre">&gt;</span>
<span class="pre">struct</span> <span class="pre">range_iterator;</span></tt></p>
<ul class="simple">
<li><em>Definition of type</em>: Let <tt class="docutils literal"><span class="pre">ptr</span></tt> be a variable of type <tt class="docutils literal"><span class="pre">Range*</span></tt>, then the nested type is
<tt class="docutils literal"><span class="pre">typedef</span> <span class="pre">decltype(</span> <span class="pre">begin(*ptr)</span> <span class="pre">)</span> <span class="pre">type;</span></tt></li>
</ul>
<p><tt class="docutils literal"><span class="pre">template&lt;</span> <span class="pre">class</span> <span class="pre">BidirectionalRange</span> <span class="pre">&gt;</span>
<span class="pre">struct</span> <span class="pre">range_reverse_iterator;</span></tt></p>
<ul class="simple">
<li><em>Definition of type</em>: <tt class="docutils literal"><span class="pre">typedef</span> <span class="pre">reverse_iterator&lt;</span> <span class="pre">typename</span> <span class="pre">range_iterator&lt;BidirectionalRange&gt;:type</span> <span class="pre">&gt;</span> <span class="pre">type;</span></tt></li>
</ul>
<p><tt class="docutils literal"><span class="pre">template&lt;</span> <span class="pre">class</span> <span class="pre">Range</span> <span class="pre">&gt;</span>
<span class="pre">struct</span> <span class="pre">range_value;</span></tt></p>
<ul class="simple">
<li><em>Definition of type</em>: <tt class="docutils literal"><span class="pre">typedef</span> <span class="pre">typename</span> <span class="pre">iterator_traits&lt;</span> <span class="pre">typename</span> <span class="pre">range_iterator&lt;Range&gt;::type</span> <span class="pre">&gt;::value_type</span> <span class="pre">type;</span></tt></li>
</ul>
<p><tt class="docutils literal"><span class="pre">template&lt;</span> <span class="pre">class</span> <span class="pre">Range</span> <span class="pre">&gt;</span>
<span class="pre">struct</span> <span class="pre">range_reference;</span></tt></p>
<ul class="simple">
<li><em>Definition of type</em>: <tt class="docutils literal"><span class="pre">typedef</span> <span class="pre">typename</span> <span class="pre">iterator_traits&lt;</span> <span class="pre">typename</span> <span class="pre">range_iterator&lt;Range&gt;::type</span> <span class="pre">&gt;::reference</span> <span class="pre">type;</span></tt></li>
</ul>
<p><tt class="docutils literal"><span class="pre">template&lt;</span> <span class="pre">class</span> <span class="pre">Range</span> <span class="pre">&gt;</span>
<span class="pre">struct</span> <span class="pre">range_pointer;</span></tt></p>
<ul class="simple">
<li><em>Definition of type</em>: <tt class="docutils literal"><span class="pre">typedef</span> <span class="pre">typename</span> <span class="pre">iterator_traits&lt;</span> <span class="pre">typename</span> <span class="pre">range_iterator&lt;Range&gt;::type</span> <span class="pre">&gt;::pointer</span> <span class="pre">type;</span></tt></li>
</ul>
<p><tt class="docutils literal"><span class="pre">template&lt;</span> <span class="pre">class</span> <span class="pre">Range</span> <span class="pre">&gt;</span>
<span class="pre">struct</span> <span class="pre">range_difference;</span></tt></p>
<ul class="simple">
<li><em>Definition of type</em>: <tt class="docutils literal"><span class="pre">typedef</span> <span class="pre">typename</span> <span class="pre">iterator_traits&lt;</span> <span class="pre">typename</span> <span class="pre">range_iterator&lt;Range&gt;::type</span> <span class="pre">&gt;::difference_type</span> <span class="pre">type;</span></tt></li>
</ul>
<p><tt class="docutils literal"><span class="pre">template&lt;</span> <span class="pre">class</span> <span class="pre">Range</span> <span class="pre">&gt;</span>
<span class="pre">struct</span> <span class="pre">range_category;</span></tt></p>
<ul class="simple">
<li><em>Definition of type</em>: <tt class="docutils literal"><span class="pre">typedef</span> <span class="pre">typename</span> <span class="pre">iterator_traits&lt;</span> <span class="pre">typename</span> <span class="pre">range_iterator&lt;Range&gt;::type</span> <span class="pre">&gt;::iterator_category</span> <span class="pre">type;</span></tt></li>
</ul>
</div>
<div class="section">
<h3><a class="toc-backref" href="#id9" id="range-utilities" name="range-utilities">24.6.3 Range utilities</a></h3>
<p>For convenience the library provides two iterator-view helper classes. 
These two classes make comparison between view-objects and container-objects easy
and provide a safer and more convenient encapsulation of iterator-views.</p>
<pre class="literal-block">
namespace std
{
        template&lt; class Iterator &gt;
        class range
        {
        public: // types
                typedef typename iterator_traits&lt;Iterator&gt;::value_type       value_type;
                typedef typename iterator_traits&lt;Iterator&gt;::reference        reference;
                typedef typename iterator_traits&lt;Iterator&gt;::difference_type  difference_type;
                typedef Iterator                                             iterator;
                typedef Iterator                                             const_iterator;
        
        public: // construction, assignment
                range();
                
                template&lt; class Iterator2 &gt;
                range( const Iterator2&amp; begin, const Iterator2&amp; end );
                        
                template&lt; class Range &gt;
                range( Range&amp;&amp; r );
        
                template&lt; class Range &gt;
                range&amp; operator=( Range&amp;&amp; r );
        
        public: // forward range functions
                iterator        begin() const;
                iterator        end() const;
                difference_type size() const;
                bool            empty() const;
                
        public: // convenience
                operator    <em>unspecified_bool_type()</em> const;
                bool        equal( const range&amp; ) const;
                reference   front() const;
                reference   back() const;
                reference   operator[]( difference_type at ) const;
                range&amp;      advance_begin( difference_type n );
                range&amp;      advance_end( difference_type n );
        
        private:
                Iterator first; // exposition only
                Iterator last;  // exposition only    
        }; 

        template&lt; class Range &gt;
        class sub_range : public range&lt; typename range_iterator&lt;Range&gt;::type &gt;
        {
        public: 
                typedef range&lt; typename range_iterator&lt;Range&gt;::type &gt;        base_type
                typedef typename range_iterator&lt;Range&gt;::type                 iterator;
                typedef typename range_iterator&lt;const Range&gt;::type           const_iterator;
                typedef typename iterator_traits&lt;const_iterator&gt;::reference  const_reference;
                using base_type::value_type;
                using base_type::reference;
                using base_type::difference_type;
                
        public: // construction, assignment
                sub_range();
                
                template&lt; class Iterator &gt;
                sub_range( const Iterator&amp; begin, const Iterator&amp; end );
                
                template&lt; class Range2 &gt;
                sub_range( Range2&amp;&amp; r );
                 
                template&lt; class Range2 &gt;
                sub_range&amp; operator=( Range2&amp;&amp; r );
                
        public:  // forward range functions 
                iterator        begin();
                const_iterator  begin() const;
                iterator        end();
                const_iterator  end() const;    
                
        public: // convenience 
                reference        front();
                const_reference  front() const;
                reference        back();
                const_reference  back() const;
                reference        operator[]( difference_type at );
                const_reference  operator[]( difference_type at ) const;   
                sub_range&amp;       advance_begin( difference_type n );
                sub_range&amp;       advance_end( difference_type n );
        };
}
</pre>
<p>[<em>Example:</em> An efficient way to find and manipulate a substring may be done with <tt class="docutils literal"><span class="pre">sub_range</span></tt>:</p>
<pre class="literal-block">
string s = ...;
sub_range&lt;string&gt; sub = find( s, ... );
if( sub == string(&quot;foo&quot;) )
{ 
   sub[0] = 'b'; 
   assert( sub == string(&quot;boo&quot;) );
}
</pre>
<p>-- <em>end example</em>]</p>
<p><tt class="docutils literal"><span class="pre">range();</span></tt></p>
<ul class="simple">
<li><em>Effects</em>: Initializes its members as if implemented by: <tt class="docutils literal"><span class="pre">range()</span> <span class="pre">:</span> <span class="pre">first(),</span> <span class="pre">last()</span> <span class="pre">{}</span></tt></li>
<li><em>Remarks</em>: The stored iterators are singular.</li>
</ul>
<p><tt class="docutils literal"><span class="pre">template&lt;</span> <span class="pre">class</span> <span class="pre">Iterator2</span> <span class="pre">&gt;</span>
<span class="pre">range(</span> <span class="pre">const</span> <span class="pre">Iterator2&amp;</span> <span class="pre">begin,</span> <span class="pre">const</span> <span class="pre">Iterator2&amp;</span> <span class="pre">end</span> <span class="pre">);</span></tt></p>
<ul class="simple">
<li><em>Effects</em>: Initializes <tt class="docutils literal"><span class="pre">first</span></tt> with <tt class="docutils literal"><span class="pre">begin</span></tt> and <tt class="docutils literal"><span class="pre">last</span></tt> with <tt class="docutils literal"><span class="pre">end</span></tt>.</li>
</ul>
<p><tt class="docutils literal"><span class="pre">template&lt;</span> <span class="pre">class</span> <span class="pre">Range</span> <span class="pre">&gt;</span>
<span class="pre">range(</span> <span class="pre">Range&amp;&amp;</span> <span class="pre">r</span> <span class="pre">);</span></tt></p>
<ul class="simple">
<li><em>Effects</em>: Initializes <tt class="docutils literal"><span class="pre">first</span></tt> with  <tt class="docutils literal"><span class="pre">std::begin(r)</span></tt> and <tt class="docutils literal"><span class="pre">last</span></tt> with <tt class="docutils literal"><span class="pre">std::end(r)</span></tt>.</li>
</ul>
<p><tt class="docutils literal"><span class="pre">template&lt;</span> <span class="pre">class</span> <span class="pre">Range</span> <span class="pre">&gt;</span>
<span class="pre">range&amp;</span> <span class="pre">operator=(</span> <span class="pre">Range&amp;&amp;</span> <span class="pre">r</span> <span class="pre">);</span></tt></p>
<ul class="simple">
<li><em>Effects</em>: assigns <tt class="docutils literal"><span class="pre">std::begin(r)</span></tt> to first and <tt class="docutils literal"><span class="pre">std::end(r)</span></tt> to <tt class="docutils literal"><span class="pre">last</span></tt>.</li>
<li><em>Returns</em>: <tt class="docutils literal"><span class="pre">*this</span></tt></li>
</ul>
<p><tt class="docutils literal"><span class="pre">iterator</span> <span class="pre">begin()</span> <span class="pre">const;</span></tt></p>
<ul class="simple">
<li><em>Returns</em>: <tt class="docutils literal"><span class="pre">first</span></tt>.</li>
</ul>
<p><tt class="docutils literal"><span class="pre">iterator</span> <span class="pre">end()</span> <span class="pre">const;</span></tt></p>
<ul class="simple">
<li><em>Returns</em>: <tt class="docutils literal"><span class="pre">last</span></tt>.</li>
</ul>
<p><tt class="docutils literal"><span class="pre">difference_type</span> <span class="pre">size()</span> <span class="pre">const;</span></tt></p>
<ul class="simple">
<li><em>Returns</em>: <tt class="docutils literal"><span class="pre">end()</span> <span class="pre">-</span> <span class="pre">begin();</span></tt></li>
</ul>
<p><tt class="docutils literal"><span class="pre">bool</span> <span class="pre">empty()</span> <span class="pre">const;</span></tt></p>
<ul class="simple">
<li><em>Returns</em>: <tt class="docutils literal"><span class="pre">begin()</span> <span class="pre">==</span> <span class="pre">end();</span></tt></li>
</ul>
<pre class="literal-block">
operator <em>unspecified_bool_type()</em> const;
</pre>
<ul class="simple">
<li><em>Returns</em>: a value convertible to <tt class="docutils literal"><span class="pre">bool</span></tt> indicating
whether <tt class="docutils literal"><span class="pre">empty()</span></tt> is true.</li>
</ul>
<p><tt class="docutils literal"><span class="pre">bool</span> <span class="pre">equal(</span> <span class="pre">const</span> <span class="pre">range&amp;</span> <span class="pre">)</span> <span class="pre">const;</span></tt></p>
<ul class="simple">
<li><em>Returns</em>: <tt class="docutils literal"><span class="pre">begin()</span> <span class="pre">==</span> <span class="pre">r.begin()</span> <span class="pre">&amp;&amp;</span> <span class="pre">end()</span> <span class="pre">==</span> <span class="pre">r.end()</span></tt>.</li>
</ul>
<p><tt class="docutils literal"><span class="pre">reference</span> <span class="pre">front()</span> <span class="pre">const;</span></tt></p>
<ul class="simple">
<li><em>Returns</em>: <tt class="docutils literal"><span class="pre">*begin()</span></tt>.</li>
</ul>
<p><tt class="docutils literal"><span class="pre">reference</span> <span class="pre">back()</span> <span class="pre">const;</span></tt></p>
<ul class="simple">
<li><em>Returns</em>: <tt class="docutils literal"><span class="pre">*--end()</span></tt>.</li>
</ul>
<p><tt class="docutils literal"><span class="pre">reference</span> <span class="pre">operator[](</span> <span class="pre">difference_type</span> <span class="pre">at</span> <span class="pre">)</span> <span class="pre">const;</span></tt></p>
<ul class="simple">
<li><em>Precondition</em>: <tt class="docutils literal"><span class="pre">0</span> <span class="pre">&lt;=</span> <span class="pre">at</span> <span class="pre">&lt;</span> <span class="pre">size()</span></tt>.</li>
<li><em>Returns</em>: <tt class="docutils literal"><span class="pre">*(begin()</span> <span class="pre">+</span> <span class="pre">at)</span></tt>.</li>
</ul>
<p><tt class="docutils literal"><span class="pre">range&amp;</span> <span class="pre">advance_begin(</span> <span class="pre">difference_type</span> <span class="pre">n</span> <span class="pre">);</span></tt></p>
<ul class="simple">
<li><em>Effects</em>: <tt class="docutils literal"><span class="pre">std::advance(first,n)</span></tt>.</li>
<li><em>Returns</em>: <tt class="docutils literal"><span class="pre">*this</span></tt></li>
</ul>
<p><tt class="docutils literal"><span class="pre">range&amp;</span> <span class="pre">advance_end(</span> <span class="pre">difference_type</span> <span class="pre">n</span> <span class="pre">);</span></tt></p>
<ul class="simple">
<li><em>Effects</em>: <tt class="docutils literal"><span class="pre">std::advance(last,n)</span></tt>.</li>
<li><em>Returns</em>: <tt class="docutils literal"><span class="pre">*this</span></tt></li>
</ul>
<p><tt class="docutils literal"><span class="pre">sub_range();</span></tt></p>
<p><tt class="docutils literal"><span class="pre">template&lt;</span> <span class="pre">class</span> <span class="pre">Iterator</span> <span class="pre">&gt;</span>
<span class="pre">sub_range(</span> <span class="pre">const</span> <span class="pre">Iterator&amp;</span> <span class="pre">begin,</span> <span class="pre">const</span> <span class="pre">Iterator&amp;</span> <span class="pre">end</span> <span class="pre">);</span></tt></p>
<p><tt class="docutils literal"><span class="pre">template&lt;</span> <span class="pre">class</span> <span class="pre">Range2</span> <span class="pre">&gt;</span>
<span class="pre">sub_range(</span> <span class="pre">Range2&amp;&amp;</span> <span class="pre">r</span> <span class="pre">);</span></tt></p>
<ul class="simple">
<li><em>Effects</em>: Calls corresponding base class constructor.</li>
</ul>
<p><tt class="docutils literal"><span class="pre">template&lt;</span> <span class="pre">class</span> <span class="pre">Range2</span> <span class="pre">&gt;</span>
<span class="pre">sub_range&amp;</span> <span class="pre">operator=(</span> <span class="pre">Range2&amp;&amp;</span> <span class="pre">r</span> <span class="pre">);</span></tt></p>
<ul class="simple">
<li><em>Effects</em>: <tt class="docutils literal"><span class="pre">base_type::operator=(r);</span></tt></li>
<li><em>Returns</em>: <tt class="docutils literal"><span class="pre">*this</span></tt></li>
</ul>
<p><tt class="docutils literal"><span class="pre">iterator</span> <span class="pre">begin();</span></tt></p>
<ul class="simple">
<li><em>Returns</em>: <tt class="docutils literal"><span class="pre">base_type::begin();</span></tt></li>
</ul>
<p><tt class="docutils literal"><span class="pre">const_iterator</span> <span class="pre">begin()</span> <span class="pre">const;</span></tt></p>
<ul class="simple">
<li><em>Returns</em>: <tt class="docutils literal"><span class="pre">base_type::begin();</span></tt></li>
</ul>
<p><tt class="docutils literal"><span class="pre">iterator</span> <span class="pre">end();</span></tt></p>
<ul class="simple">
<li><em>Returns</em>: <tt class="docutils literal"><span class="pre">base_type::end();</span></tt></li>
</ul>
<p><tt class="docutils literal"><span class="pre">const_iterator</span> <span class="pre">end()</span> <span class="pre">const;</span></tt></p>
<ul class="simple">
<li><em>Returns</em>: <tt class="docutils literal"><span class="pre">base_type::end();</span></tt></li>
</ul>
<p><tt class="docutils literal"><span class="pre">reference</span> <span class="pre">front();</span></tt></p>
<ul class="simple">
<li><em>Returns</em>: <tt class="docutils literal"><span class="pre">base_type::front();</span></tt></li>
</ul>
<p><tt class="docutils literal"><span class="pre">const_reference</span> <span class="pre">front()</span> <span class="pre">const;</span></tt></p>
<ul class="simple">
<li><em>Returns</em>: <tt class="docutils literal"><span class="pre">base_type::front();</span></tt></li>
</ul>
<p><tt class="docutils literal"><span class="pre">reference</span> <span class="pre">back();</span></tt></p>
<ul class="simple">
<li><em>Returns</em>: <tt class="docutils literal"><span class="pre">base_type::back();</span></tt></li>
</ul>
<p><tt class="docutils literal"><span class="pre">const_reference</span> <span class="pre">back()</span> <span class="pre">const;</span></tt></p>
<ul class="simple">
<li><em>Returns</em>: <tt class="docutils literal"><span class="pre">base_type::back();</span></tt></li>
</ul>
<p><tt class="docutils literal"><span class="pre">reference</span> <span class="pre">operator[](</span> <span class="pre">difference_type</span> <span class="pre">at</span> <span class="pre">);</span></tt></p>
<ul class="simple">
<li><em>Returns</em>: <tt class="docutils literal"><span class="pre">base_type::operator[](at);</span></tt></li>
</ul>
<p><tt class="docutils literal"><span class="pre">const_reference</span> <span class="pre">operator[](</span> <span class="pre">difference_type</span> <span class="pre">at</span> <span class="pre">)</span> <span class="pre">const;</span></tt></p>
<ul class="simple">
<li><em>Returns</em>: <tt class="docutils literal"><span class="pre">base_type::operator[](at);</span></tt></li>
</ul>
<p><tt class="docutils literal"><span class="pre">sub_range&amp;</span> <span class="pre">advance_begin(</span> <span class="pre">difference_type</span> <span class="pre">n</span> <span class="pre">);</span></tt></p>
<ul class="simple">
<li><em>Effects</em>: <tt class="docutils literal"><span class="pre">base_type::advance_begin(n);</span></tt></li>
<li><em>Returns</em>: <tt class="docutils literal"><span class="pre">*this</span></tt></li>
</ul>
<p><tt class="docutils literal"><span class="pre">sub_range&amp;</span> <span class="pre">advance_end(</span> <span class="pre">difference_type</span> <span class="pre">n</span> <span class="pre">);</span></tt></p>
<ul class="simple">
<li><em>Effects</em>: <tt class="docutils literal"><span class="pre">base_type::advance_end(n);</span></tt></li>
<li><em>Returns</em>: <tt class="docutils literal"><span class="pre">*this</span></tt></li>
</ul>
<p><tt class="docutils literal"><span class="pre">template&lt;</span> <span class="pre">class</span> <span class="pre">Iterator,</span> <span class="pre">class</span> <span class="pre">T,</span> <span class="pre">class</span> <span class="pre">Traits</span> <span class="pre">&gt;</span>
<span class="pre">std::basic_ostream&lt;T,Traits&gt;&amp;</span> 
<span class="pre">operator&lt;&lt;(</span> <span class="pre">std::basic_ostream&lt;T,Traits&gt;&amp;</span> <span class="pre">Os,</span> <span class="pre">const</span> <span class="pre">range&lt;Iterator&gt;&amp;</span> <span class="pre">r</span> <span class="pre">);</span></tt></p>
<ul class="simple">
<li><em>Effects</em>: <tt class="docutils literal"><span class="pre">std::copy(</span> <span class="pre">r.begin(),</span> <span class="pre">r.end(),</span> <span class="pre">std::ostream_iterator&lt;</span> <span class="pre">typename</span> <span class="pre">iterator_traits&lt;Iterator&gt;::value_type,T,Traits&gt;(os));</span> <span class="pre">return</span> <span class="pre">Os;</span></tt>.</li>
</ul>
<p><tt class="docutils literal"><span class="pre">template&lt;</span> <span class="pre">class</span> <span class="pre">Iterator,</span> <span class="pre">class</span> <span class="pre">Iterator2</span> <span class="pre">&gt;</span>
<span class="pre">bool</span> <span class="pre">operator==(</span> <span class="pre">const</span> <span class="pre">range&lt;Iterator&gt;&amp;</span> <span class="pre">l,</span> <span class="pre">const</span> <span class="pre">range&lt;Iterator2&gt;&amp;</span> <span class="pre">r</span> <span class="pre">);</span></tt></p>
<p><tt class="docutils literal"><span class="pre">template&lt;</span> <span class="pre">class</span> <span class="pre">Iterator,</span> <span class="pre">class</span> <span class="pre">Range</span> <span class="pre">&gt;</span>
<span class="pre">bool</span> <span class="pre">operator==(</span> <span class="pre">const</span> <span class="pre">range&lt;Iterator&gt;&amp;</span> <span class="pre">l,</span> <span class="pre">const</span> <span class="pre">Range&amp;</span> <span class="pre">r</span> <span class="pre">);</span></tt></p>
<p><tt class="docutils literal"><span class="pre">template&lt;</span> <span class="pre">class</span> <span class="pre">Iterator,</span> <span class="pre">class</span> <span class="pre">Range</span> <span class="pre">&gt;</span>
<span class="pre">bool</span> <span class="pre">operator==(</span> <span class="pre">const</span> <span class="pre">Range&amp;</span> <span class="pre">l,</span> <span class="pre">const</span> <span class="pre">range&lt;Iterator&gt;&amp;</span> <span class="pre">r</span> <span class="pre">);</span></tt></p>
<ul class="simple">
<li><em>Returns</em>: <tt class="docutils literal"><span class="pre">std::equal(</span> <span class="pre">std::begin(l),</span> <span class="pre">std::end(l),</span> <span class="pre">std::begin(r)</span> <span class="pre">);</span></tt>.</li>
<li><em>Remarks</em>: For random access ranges the function compares the
size of the ranges first via <tt class="docutils literal"><span class="pre">std::size()</span></tt>.</li>
</ul>
<p><tt class="docutils literal"><span class="pre">template&lt;</span> <span class="pre">class</span> <span class="pre">Iterator,</span> <span class="pre">class</span> <span class="pre">Iterator2</span> <span class="pre">&gt;</span>
<span class="pre">bool</span> <span class="pre">operator!=(</span> <span class="pre">const</span> <span class="pre">range&lt;Iterator&gt;&amp;</span> <span class="pre">l,</span> <span class="pre">const</span> <span class="pre">range&lt;Iterator2&gt;&amp;</span> <span class="pre">r</span> <span class="pre">);</span></tt></p>
<p><tt class="docutils literal"><span class="pre">template&lt;</span> <span class="pre">class</span> <span class="pre">Iterator,</span> <span class="pre">class</span> <span class="pre">Range</span> <span class="pre">&gt;</span>
<span class="pre">bool</span> <span class="pre">operator!=(</span> <span class="pre">const</span> <span class="pre">range&lt;Iterator&gt;&amp;</span> <span class="pre">l,</span> <span class="pre">const</span> <span class="pre">Range&amp;</span> <span class="pre">r</span> <span class="pre">);</span></tt></p>
<p><tt class="docutils literal"><span class="pre">template&lt;</span> <span class="pre">class</span> <span class="pre">Iterator,</span> <span class="pre">class</span> <span class="pre">Range</span> <span class="pre">&gt;</span>
<span class="pre">bool</span> <span class="pre">operator!=(</span> <span class="pre">const</span> <span class="pre">Range&amp;</span> <span class="pre">l,</span> <span class="pre">const</span> <span class="pre">range&lt;Iterator&gt;&amp;</span> <span class="pre">r</span> <span class="pre">);</span></tt></p>
<ul class="simple">
<li><em>Returns</em>: <tt class="docutils literal"><span class="pre">!(</span> <span class="pre">l</span> <span class="pre">==</span> <span class="pre">r</span> <span class="pre">)</span></tt>.</li>
</ul>
<p><tt class="docutils literal"><span class="pre">template&lt;</span> <span class="pre">class</span> <span class="pre">Iterator,</span> <span class="pre">class</span> <span class="pre">Iterator2</span> <span class="pre">&gt;</span>
<span class="pre">bool</span> <span class="pre">operator&lt;(</span> <span class="pre">const</span> <span class="pre">range&lt;Iterator&gt;&amp;</span> <span class="pre">l,</span> <span class="pre">const</span> <span class="pre">range&lt;Iterator2&gt;&amp;</span> <span class="pre">r</span> <span class="pre">);</span></tt></p>
<p><tt class="docutils literal"><span class="pre">template&lt;</span> <span class="pre">class</span> <span class="pre">Iterator,</span> <span class="pre">class</span> <span class="pre">Range</span> <span class="pre">&gt;</span>
<span class="pre">bool</span> <span class="pre">operator&lt;(</span> <span class="pre">const</span> <span class="pre">range&lt;Iterator&gt;&amp;</span> <span class="pre">l,</span> <span class="pre">const</span> <span class="pre">Range&amp;</span> <span class="pre">r</span> <span class="pre">);</span></tt></p>
<p><tt class="docutils literal"><span class="pre">template&lt;</span> <span class="pre">class</span> <span class="pre">Iterator,</span> <span class="pre">class</span> <span class="pre">Range</span> <span class="pre">&gt;</span>
<span class="pre">bool</span> <span class="pre">operator&lt;(</span> <span class="pre">const</span> <span class="pre">Range&amp;</span> <span class="pre">l,</span> <span class="pre">const</span> <span class="pre">range&lt;Iterator&gt;&amp;</span> <span class="pre">r</span> <span class="pre">);</span></tt></p>
<ul class="simple">
<li><em>Returns</em>: <tt class="docutils literal"><span class="pre">std::lexicographical_compare(std::begin(l),std::end(l),std::begin(r),</span> <span class="pre">std::end(r))</span></tt>.</li>
</ul>
<p><tt class="docutils literal"><span class="pre">template&lt;</span> <span class="pre">class</span> <span class="pre">Range,</span> <span class="pre">class</span> <span class="pre">Range2</span> <span class="pre">&gt;</span>
<span class="pre">bool</span> <span class="pre">operator==(</span> <span class="pre">const</span> <span class="pre">sub_range&lt;Range&gt;&amp;</span> <span class="pre">l,</span> <span class="pre">const</span> <span class="pre">sub_range&lt;Range2&gt;&amp;</span> <span class="pre">r</span> <span class="pre">);</span></tt></p>
<p><tt class="docutils literal"><span class="pre">template&lt;</span> <span class="pre">class</span> <span class="pre">Range,</span> <span class="pre">class</span> <span class="pre">Range2</span> <span class="pre">&gt;</span>
<span class="pre">bool</span> <span class="pre">operator!=(</span> <span class="pre">const</span> <span class="pre">sub_range&lt;Range&gt;&amp;</span> <span class="pre">l,</span> <span class="pre">const</span> <span class="pre">sub_range&lt;Range2&gt;&amp;</span> <span class="pre">r</span> <span class="pre">)</span></tt></p>
<p><tt class="docutils literal"><span class="pre">template&lt;</span> <span class="pre">class</span> <span class="pre">Range,</span> <span class="pre">class</span> <span class="pre">Range2</span> <span class="pre">&gt;</span>
<span class="pre">bool</span> <span class="pre">operator&lt;(</span> <span class="pre">const</span> <span class="pre">sub_range&lt;Range&gt;&amp;</span> <span class="pre">l,</span> <span class="pre">const</span> <span class="pre">sub_range&lt;Range2&gt;&amp;</span> <span class="pre">r</span> <span class="pre">);</span></tt></p>
<ul class="simple">
<li><em>Effects</em>: forwards to <tt class="docutils literal"><span class="pre">range</span></tt> version via static casts to a reference to the base class</li>
<li><em>Remarks</em>: these functions are needed to avoid ambiguity during overload resolution.</li>
</ul>
<p><tt class="docutils literal"><span class="pre">template&lt;</span> <span class="pre">class</span> <span class="pre">Iterator</span> <span class="pre">&gt;</span>
<span class="pre">range&lt;Iterator&gt;</span>
<span class="pre">make_range(</span> <span class="pre">const</span> <span class="pre">Iterator&amp;</span> <span class="pre">begin,</span> <span class="pre">const</span> <span class="pre">Iterator&amp;</span> <span class="pre">end</span> <span class="pre">);</span></tt></p>
<ul class="simple">
<li><em>Returns</em>: <tt class="docutils literal"><span class="pre">range&lt;Iterator&gt;(begin,end)</span></tt>.</li>
</ul>
<p><tt class="docutils literal"><span class="pre">template&lt;</span> <span class="pre">class</span> <span class="pre">Range</span> <span class="pre">&gt;</span>
<span class="pre">range&lt;typename</span> <span class="pre">range_iterator&lt;Range&gt;::type&gt;</span> 
<span class="pre">make_range(</span> <span class="pre">Range&amp;&amp;</span> <span class="pre">r</span> <span class="pre">);</span></tt></p>
<ul class="simple">
<li><em>Returns</em>: <tt class="docutils literal"><span class="pre">range&lt;typename</span> <span class="pre">range_iterator&lt;Range&gt;::type&gt;(r)</span></tt>.</li>
</ul>
<p><tt class="docutils literal"><span class="pre">template&lt;</span> <span class="pre">class</span> <span class="pre">Range</span> <span class="pre">&gt;</span>
<span class="pre">range&lt;typename</span> <span class="pre">range_iterator&lt;Range&gt;::type&gt;</span> 
<span class="pre">make_range(</span> <span class="pre">Range&amp;&amp;</span> <span class="pre">r,</span> <span class="pre">typename</span> <span class="pre">range_difference&lt;Range&gt;::type</span> <span class="pre">N,</span> <span class="pre">typename</span> <span class="pre">range_difference&lt;Range&gt;::type</span> <span class="pre">M</span> <span class="pre">);</span></tt></p>
<ul class="simple">
<li><em>Effects</em>: <tt class="docutils literal"><span class="pre">range&lt;typename</span> <span class="pre">range_iterator&lt;Range&gt;::type&gt;</span> <span class="pre">tmp(r);</span> <span class="pre">tmp.advance_begin(N);</span> <span class="pre">tmp.advance_end(M);</span> <span class="pre">return</span> <span class="pre">tmp;</span></tt></li>
</ul>
<p><tt class="docutils literal"><span class="pre">template&lt;</span> <span class="pre">class</span> <span class="pre">CopyableRange,</span> <span class="pre">class</span> <span class="pre">Range</span> <span class="pre">&gt;</span> <span class="pre">CopyableRange</span> <span class="pre">copy_range(</span> <span class="pre">const</span> <span class="pre">Range&amp;</span> <span class="pre">r</span> <span class="pre">);</span></tt></p>
<ul class="simple">
<li><em>Returns</em>: <tt class="docutils literal"><span class="pre">CopyableRange(std::begin(r),std::end(r))</span></tt>.</li>
</ul>
<p><tt class="docutils literal"><span class="pre">template&lt;</span> <span class="pre">class</span> <span class="pre">ForwardRange</span> <span class="pre">&gt;</span>
<span class="pre">typename</span> <span class="pre">range_difference&lt;ForwardRange&gt;::type</span>
<span class="pre">distance(</span> <span class="pre">const</span> <span class="pre">ForwardRange&amp;</span> <span class="pre">r</span> <span class="pre">);</span></tt></p>
<ul class="simple">
<li><em>Returns</em>: <tt class="docutils literal"><span class="pre">std::distance(std::begin(r),std::end(r))</span></tt></li>
</ul>
</div>
</div>
</div>
<div class="section">
<h1><a class="toc-backref" href="#id10" id="acknowledgements" name="acknowledgements">Acknowledgements</a></h1>
<p>Thanks to Pavol Droba for our many discussions. Thanks to
Howard Hinnant, Dietmar Kuehl and Walter Brown for feedback
on the earlier version of this paper. Thanks to the Boost 
community for their feedback on Boost.Range over the years.</p>
<!-- ############################################### -->
<!-- ################## Links ###################### -->
<!-- ############################################### -->
<!-- ========= -->
<!-- Footnotes -->
<!-- ========= -->
<!-- ############################################### -->
<!-- ################## Footnotes ################## -->
<!-- ############################################### -->
</div>
</div>
</body>
</html>
