<?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>Wording for range-based for-loop (revision 3)</title>
<meta name="author" content="Thorsten Ottosen" />
<meta name="date" content="2007-09-09" />
<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="wording-for-range-based-for-loop-revision-3">
<h1 class="title">Wording for range-based for-loop (revision 3)</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:nesotto&#64;cs.aau.dk">nesotto&#64;cs.aau.dk</a></td></tr>
<tr class="field"><th class="docinfo-name">Advisor:</th><td class="field-body">Lawrence Crowl, Douglas Gregor and Jens Maurer</td>
</tr>
<tr class="field"><th class="docinfo-name">Organizations:</th><td class="field-body"><a class="reference" href="http://www.cs.aau.dk">Department of Computer Science, Aalborg University</a></td>
</tr>
<tr><th class="docinfo-name">Date:</th>
<td>2007-09-09</td></tr>
<tr class="field"><th class="docinfo-name">Number:</th><td class="field-body">WG21/N2394 and J16/07-0254</td>
</tr>
<tr class="field"><th class="docinfo-name">Working Group:</th><td class="field-body">Core</td>
</tr>
</tbody>
</table>
<div class="abstract topic">
<p class="topic-title first">Abstract</p>
<p>This paper provides wording for the new range-based for-loop 
previously described in <a class="reference" href="http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2005/n1868.html">n1868</a>, <a class="reference" href="http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2006/n1961.html">n1961</a>, <a class="reference" href="http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2006/n2049.pdf">n2049</a>, <a class="reference" href="http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2007/n2196.html">n2196</a> and <a class="reference" href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2243.html">n2243</a>.</p>
</div>
<!-- ######################### -->
<!-- # Roles -->
<!-- ######################### -->
<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="id2" name="id2">Introduction</a></li>
<li><a class="reference" href="#changes-from-n2243" id="id3" name="id3">Changes from n2243</a></li>
<li><a class="reference" href="#changes-from-n2196" id="id4" name="id4">Changes from n2196</a></li>
<li><a class="reference" href="#missing-parts" id="id5" name="id5">Missing parts</a></li>
<li><a class="reference" href="#wording" id="id6" name="id6">Wording</a><ul>
<li><a class="reference" href="#local-scope" id="id7" name="id7">3.3.2 Local scope</a></li>
<li><a class="reference" href="#iteration-statements" id="id8" name="id8">6.5 Iteration statements</a></li>
<li><a class="reference" href="#the-range-based-for-statement" id="id9" name="id9">6.5.4 The range-based <tt class="docutils literal"><span class="pre">for</span></tt> statement</a></li>
<li><a class="reference" href="#auto-specifier" id="id10" name="id10">7.1.5.4 <tt class="docutils literal"><span class="pre">auto</span></tt> specifier</a></li>
<li><a class="reference" href="#xx-x-range-concept" id="id11" name="id11">xx.x Range concept</a></li>
<li><a class="reference" href="#xx-y-header-iterator-concept-synopsis" id="id12" name="id12">xx.y Header <tt class="docutils literal"><span class="pre">&lt;iterator_concept&gt;</span></tt> synopsis</a></li>
<li><a class="reference" href="#xx-z-range-concept-maps" id="id13" name="id13">xx.z Range concept maps</a></li>
<li><a class="reference" href="#header-initializer-list" id="id14" name="id14">18.8 Header <tt class="docutils literal"><span class="pre">&lt;initializer_list&gt;</span></tt></a></li>
<li><a class="reference" href="#initializer-list-concept-maps" id="id15" name="id15">18.8.1 Initializer list concept maps</a></li>
<li><a class="reference" href="#header-utility-synopsis" id="id16" name="id16">20.2 Header <tt class="docutils literal"><span class="pre">&lt;utility&gt;</span></tt> synopsis</a></li>
<li><a class="reference" href="#pair-concept-maps" id="id17" name="id17">20.2.3 pair concept maps</a></li>
<li><a class="reference" href="#header-tuple-synopsis" id="id18" name="id18">20.3 Header <tt class="docutils literal"><span class="pre">&lt;tuple&gt;</span></tt> synopsis</a></li>
<li><a class="reference" href="#tuple-concept-maps" id="id19" name="id19">20.3.1.6 tuple concept maps</a></li>
<li><a class="reference" href="#header-valarray-synopsis" id="id20" name="id20">26.5.1 Header <tt class="docutils literal"><span class="pre">&lt;valarray&gt;</span></tt> synopsis</a></li>
<li><a class="reference" href="#valarray-concept-maps" id="id21" name="id21">26.5.2.7 valarray concept maps</a></li>
<li><a class="reference" href="#header-regex-synopsis" id="id22" name="id22">28.4 Header <tt class="docutils literal"><span class="pre">&lt;regex&gt;</span></tt> synopsis</a></li>
<li><a class="reference" href="#sub-match-concept-maps" id="id23" name="id23">28.9.3 sub_match concept maps</a></li>
</ul>
</li>
</ul>
</div>
<!-- section-numbering: -->
<div class="section">
<h1><a class="toc-backref" href="#id2" id="introduction" name="introduction">Introduction</a></h1>
<p>This document provides wording for a concept-based implementation
of the range-based for loop. The proposal is 
implemented in the latest version of Douglas Gregors <a class="reference" href="http://www.generic-programming.org/software/ConceptGCC/">Concept GCC</a>.</p>
<p>Each numbered section below describes a new section
for the standard or modifications to an existing section.
Comments are written in <strong>bold</strong> up front and are not part of the wording.</p>
<p>The author would like to thank Lawrence Crowl, Steve Adamczyk and Douglas Gregor for their help with
the first revisions. Special thanks goes to Jens Maurer for his help with this revision.
Any mistake
is the responsibility of the author.</p>
</div>
<div class="section">
<h1><a id="changes-from-n2243" name="changes-from-n2243">Changes from <a class="reference" href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2243.html">n2243</a></a></h1>
<ul>
<li><p class="first">Removed changes to 7.1.5.4/2:</p>
<p><strong>or if auto appears in a</strong> <span class="html"><i><b>for-range-declaration</i></b></span></p>
</li>
<li><p class="first">Added paragraph number to wording for <tt class="docutils literal"><span class="pre">initializer_list&lt;T&gt;</span></tt></p>
</li>
<li><p class="first">Added reference to the definition of a &quot;valid range&quot;</p>
</li>
</ul>
</div>
<div class="section">
<h1><a id="changes-from-n2196" name="changes-from-n2196">Changes from <a class="reference" href="http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2007/n2196.html">n2196</a></a></h1>
<ul class="simple">
<li>The code functionality has been moved into the header <tt class="docutils literal"><span class="pre">&lt;iterator_concept&gt;</span></tt>.</li>
<li>A concept map has been added for <tt class="docutils literal"><span class="pre">initializer_list&lt;T&gt;</span></tt>.</li>
<li>There is no longer any implicit inclusion of the <tt class="docutils literal"><span class="pre">&lt;iterator_concept&gt;</span></tt> header.</li>
</ul>
</div>
<div class="section">
<h1><a class="toc-backref" href="#id5" id="missing-parts" name="missing-parts">Missing parts</a></h1>
<p>The layout of concept headers is not yet finalized. This will only
affect the library wording in minor ways and so the wording is included
with any reference to the exact section in the standard.</p>
</div>
<div class="section">
<h1><a class="toc-backref" href="#id6" id="wording" name="wording">Wording</a></h1>
<div class="section">
<h2><a class="toc-backref" href="#id7" id="local-scope" name="local-scope">3.3.2 Local scope</a></h2>
<p><strong>Modify paragraph 4 as indicated</strong>:</p>
<!-- parsed-literal: -->
<p>Names declared in the <em>for-init-statement</em>, <span class="html"><b>the <i>for-range-declaration</i></b></span>, and 
in the condition of if, while, for, and switch statements are local to the 
if, while, for, or switch statement (including the controlled statement), 
and shall not be redeclared in a subsequent condition of that statement 
nor in the outermost block (or, for the if statement, any of the outermost 
blocks) of the controlled statement; see 6.4 stmt.select.</p>
</div>
<div class="section">
<h2><a class="toc-backref" href="#id8" id="iteration-statements" name="iteration-statements">6.5 Iteration statements</a></h2>
<p><strong>Modify paragraph 1 as indicated</strong>:</p>
<pre class="literal-block">
iteration-statement:
        while ( condition ) statement
        do statement while ( expression ) ;
        for ( for-init-statement condition<sub>opt</sub> ; expression<sub>opt</sub> ) statement
        <strong>for ( for-range-declaration : expression ) statement</strong>

for-init-statement:
        expression-statement
        simple-declaration

<strong>for-range-declaration:</strong>
        <strong>type-specifier-seq declarator</strong>
</pre>
</div>
<div class="section">
<h2><a class="toc-backref" href="#id9" id="the-range-based-for-statement" name="the-range-based-for-statement">6.5.4 The range-based <tt class="docutils literal docutils literal"><span class="pre">for</span></tt> statement</a></h2>
<p><strong>Add the following new section</strong>:</p>
<p>1 The range-based <tt class="docutils literal"><span class="pre">for</span></tt> statement</p>
<pre class="literal-block">
for ( <em>for-range-declaration</em> : <em>expression</em> ) <em>statement</em>
</pre>
<p>is equivalent to</p>
<pre class="literal-block">
{
     auto &amp;&amp; __range = ( <em>expression</em> );
    
     for ( auto __begin = std::Range&lt;_RangeT&gt;::begin(__range),
                  __end = std::Range&lt;_RangeT&gt;::end(__range);
          __begin != __end;
          ++__begin )
     {
         <em>for-range-declaration</em> = *__begin;
         <em>statement</em>
     }    
}
</pre>
<p>where <tt class="docutils literal"><span class="pre">__range</span></tt>, <tt class="docutils literal"><span class="pre">__begin</span></tt> and <tt class="docutils literal"><span class="pre">__end</span></tt> are variables defined for exposition only, and <tt class="docutils literal"><span class="pre">_RangeT</span></tt> is the type of the <em>expression</em>.</p>
<p>[<em>Example:</em></p>
<pre class="literal-block">
int array[5] =  { 1,2,3,4,5 };
for ( int&amp; x : array )
  x *= 2;
</pre>
<p>-- <em>end example</em>]</p>
<p>2 If the header <tt class="docutils literal"><span class="pre">&lt;iterator_concept&gt;</span></tt> is not included prior to a use of the range-based <tt class="docutils literal"><span class="pre">for</span></tt> statement, the program is ill-formed.</p>
</div>
<div class="section">
<h2><a class="toc-backref" href="#id10" id="auto-specifier" name="auto-specifier">7.1.5.4 <tt class="docutils literal docutils literal"><span class="pre">auto</span></tt> specifier</a></h2>
<p><strong>Modify paragraph 3 as indicated</strong>:</p>
<p>3 This use of auto is allowed when declaring 
objects in a block (6.3 stmt.block), in namespace scope (3.3.5 
basic.scope.namespace), <span class="html"><strike>and</strike></span> in a <em>for-init-statement</em> <span class="html"><strike>(6.5.3 stmt.for)</strike></span>, <strong>and 
in a</strong> <span class="html"><i><b>for-range-declaration</i> (6.5.3 stmt.for).</b></span></p>
<!-- 3 This use of ``auto`` is allowed when declaring objects in a block (6.3), in namespace scope (3.3.5), in a *for-init-statement* (6.5.3), and in -->
<!-- a *type-specifier-seq* for the range-based ``for`` statement (6.5.4). -->
</div>
<div class="section">
<h2><a class="toc-backref" href="#id11" id="xx-x-range-concept" name="xx-x-range-concept">xx.x Range concept</a></h2>
<p><strong>Add the following to the section that describes header &lt;iterator_concept&gt;</strong>:</p>
<p>1 A class or a built-in type <tt class="docutils literal"><span class="pre">T</span></tt> satisfies the requirement of a range if it
meets the syntactic and semantic requirements of the <tt class="docutils literal"><span class="pre">Range</span></tt> concept.</p>
<pre class="literal-block">
concept Range&lt; typename T &gt;
{
    InputIterator iterator;
    iterator begin( T&amp; );
    iterator end( T&amp; );
};
</pre>
<p>2 For an object <tt class="docutils literal"><span class="pre">t</span></tt> of a type <tt class="docutils literal"><span class="pre">T</span></tt> conforming to the <tt class="docutils literal"><span class="pre">Range</span></tt> concept,  
<tt class="docutils literal"><span class="pre">[Range&lt;T&gt;::begin(t),Range&lt;T&gt;::end(t))</span></tt> designates a valid range (24.1.7).</p>
<p>3 Any object of a type conforming to the <tt class="docutils literal"><span class="pre">Range</span></tt> concept can be used with the range-based <tt class="docutils literal"><span class="pre">for</span></tt> statement (6.5.4)</p>
</div>
<div class="section">
<h2><a class="toc-backref" href="#id12" id="xx-y-header-iterator-concept-synopsis" name="xx-y-header-iterator-concept-synopsis">xx.y Header <tt class="docutils literal docutils literal"><span class="pre">&lt;iterator_concept&gt;</span></tt> synopsis</a></h2>
<p><strong>Add the following new section</strong>:</p>
<pre class="literal-block">
namespace std 
{
  template&lt; class T, size_t N &gt;
  concept_map Range&lt; T[N] &gt;
  { <em>see below</em> }
  
  template&lt;Container C&gt; 
  concept_map Range&lt;C&gt; 
  { <em>see below</em> }
 
  template&lt;Container C&gt; 
  concept_map Range&lt;const C&gt; 
  { <em>see below</em> } 
}
</pre>
</div>
<div class="section">
<h2><a class="toc-backref" href="#id13" id="xx-z-range-concept-maps" name="xx-z-range-concept-maps">xx.z Range concept maps</a></h2>
<p><strong>Add the following new section</strong>:</p>
<p>1 Array objects can be used with the range-based <tt class="docutils literal"><span class="pre">for</span></tt> statement due to
the following concept map:</p>
<pre class="literal-block">
template&lt; class T, size_t N &gt;
concept_map Range&lt; T[N] &gt;
{
    typedef T* iterator;
    iterator begin( T(&amp;a)[N] );
    iterator end( T(&amp;a)[N] );
};
</pre>
<ul class="simple">
<li><tt class="docutils literal"><span class="pre">iterator</span> <span class="pre">begin(</span> <span class="pre">T(&amp;a)[N]</span> <span class="pre">);</span></tt></li>
</ul>
<p>2 <em>Returns</em>: <tt class="docutils literal"><span class="pre">a</span></tt></p>
<ul class="simple">
<li><tt class="docutils literal"><span class="pre">iterator</span> <span class="pre">end(</span> <span class="pre">T(&amp;a)[N]</span> <span class="pre">);</span></tt></li>
</ul>
<p>3 <em>Returns</em>: <tt class="docutils literal"><span class="pre">a</span> <span class="pre">+</span> <span class="pre">N</span></tt></p>
<p>4 Any object of a type that meets the requirements of the <tt class="docutils literal"><span class="pre">Container</span></tt> concept can be used
with the range-based <tt class="docutils literal"><span class="pre">for</span></tt> statement due to
the following concept maps:</p>
<pre class="literal-block">
template&lt;Container C&gt; 
concept_map Range&lt;C&gt; 
{ 
    typedef C::iterator iterator; 
    iterator begin( C&amp; c );
    iterator end( C&amp; c );
};

template&lt;Container C&gt; 
concept_map Range&lt;const C&gt; 
{ 
    typedef C::const_iterator iterator; 
    iterator begin( const C&amp; c );
    iterator end( const C&amp; c );
};
</pre>
<ul class="simple">
<li><tt class="docutils literal"><span class="pre">iterator</span> <span class="pre">begin(</span> <span class="pre">C&amp;</span> <span class="pre">c</span> <span class="pre">);</span></tt></li>
<li><tt class="docutils literal"><span class="pre">iterator</span> <span class="pre">begin(</span> <span class="pre">const</span> <span class="pre">C&amp;</span> <span class="pre">c</span> <span class="pre">);</span></tt></li>
</ul>
<p>5 <em>Returns</em>: <tt class="docutils literal"><span class="pre">c.begin();</span></tt></p>
<ul class="simple">
<li><tt class="docutils literal"><span class="pre">iterator</span> <span class="pre">end(</span> <span class="pre">C&amp;</span> <span class="pre">c</span> <span class="pre">);</span></tt></li>
<li><tt class="docutils literal"><span class="pre">iterator</span> <span class="pre">end(</span> <span class="pre">const</span> <span class="pre">C&amp;</span> <span class="pre">c</span> <span class="pre">);</span></tt></li>
</ul>
<p>6 <em>Returns</em>: <tt class="docutils literal"><span class="pre">c.end()</span></tt></p>
</div>
<div class="section">
<h2><a class="toc-backref" href="#id14" id="header-initializer-list" name="header-initializer-list">18.8 Header <tt class="docutils literal docutils literal"><span class="pre">&lt;initializer_list&gt;</span></tt></a></h2>
<p><strong>Add the following to the synopsis</strong>:</p>
<pre class="literal-block">
template&lt;typename T&gt;
concept_map Range&lt; initializer_list&lt;T&gt; &gt;
{ *see below* }

template&lt;typename T&gt;
concept_map Range&lt; const initializer_list&lt;T&gt; &gt;
{ *see below* }
</pre>
</div>
<div class="section">
<h2><a class="toc-backref" href="#id15" id="initializer-list-concept-maps" name="initializer-list-concept-maps">18.8.1 Initializer list concept maps</a></h2>
<p><strong>Add the following new section that describes &lt;initializer_list&gt;</strong>:</p>
<p>1 Initializer lists can be used with the range-based <tt class="docutils literal"><span class="pre">for</span></tt> statement
due to the following concept maps:</p>
<pre class="literal-block">
template&lt;typename T&gt;
concept_map Range&lt; initializer_list&lt;T&gt; &gt;
{
    typedef const T* iterator;

    iterator begin( initializer_list&lt;T&gt;&amp; r );
    iterator end( initializer_list&lt;T&gt;&amp; r );
}

template&lt;typename T&gt;
concept_map Range&lt; const initializer_list&lt;T&gt; &gt;
{
    typedef const T* iterator;

    iterator begin( const initializer_list&lt;T&gt;&amp; r );
    iterator end( const initializer_list&lt;T&gt;&amp; r );
}
</pre>
<ul class="simple">
<li><tt class="docutils literal"><span class="pre">iterator</span> <span class="pre">begin(</span> <span class="pre">initializer_list&lt;T&gt;&amp;</span> <span class="pre">r</span> <span class="pre">);</span></tt></li>
<li><tt class="docutils literal"><span class="pre">iterator</span> <span class="pre">begin(</span> <span class="pre">const</span> <span class="pre">initializer_list&lt;T&gt;&amp;</span> <span class="pre">r</span> <span class="pre">);</span></tt></li>
</ul>
<p>2 <em>Returns</em>: <tt class="docutils literal"><span class="pre">r.begin()</span></tt></p>
<ul class="simple">
<li><tt class="docutils literal"><span class="pre">iterator</span> <span class="pre">end(</span> <span class="pre">initializer_list&lt;T&gt;&amp;</span> <span class="pre">r</span> <span class="pre">);</span></tt></li>
<li><tt class="docutils literal"><span class="pre">iterator</span> <span class="pre">end(</span> <span class="pre">const</span> <span class="pre">initializer_list&lt;T&gt;&amp;</span> <span class="pre">r</span> <span class="pre">);</span></tt></li>
</ul>
<p>3 <em>Returns</em>: <tt class="docutils literal"><span class="pre">return</span> <span class="pre">r.end()</span></tt></p>
</div>
<div class="section">
<h2><a class="toc-backref" href="#id16" id="header-utility-synopsis" name="header-utility-synopsis">20.2 Header <tt class="docutils literal docutils literal"><span class="pre">&lt;utility&gt;</span></tt> synopsis</a></h2>
<p><strong>Add the following to the synopsis</strong>:</p>
<pre class="literal-block">
template&lt;InputIterator Iter&gt; 
concept_map Range&lt; pair&lt;Iter,Iter&gt; &gt; 
{ <em>see below</em> }

template&lt;InputIterator Iter&gt; 
concept_map Range&lt; const pair&lt;Iter,Iter&gt; &gt; 
{ <em>see below</em> }
</pre>
</div>
<div class="section">
<h2><a class="toc-backref" href="#id17" id="pair-concept-maps" name="pair-concept-maps">20.2.3 pair concept maps</a></h2>
<p><strong>Add the following new section</strong>:</p>
<p>1 A <tt class="docutils literal"><span class="pre">pair</span></tt> object of two iterators can be used with the range-based <tt class="docutils literal"><span class="pre">for</span></tt> statement due to
the following concept maps:</p>
<pre class="literal-block">
template&lt;InputIterator Iter&gt; 
concept_map Range&lt; pair&lt;Iter,Iter&gt; &gt; 
{ 
    typedef Iter iterator; 
    Iter begin( pair&lt;Iter,Iter&gt;&amp; p );
    Iter end( pair&lt;Iter,Iter&gt;&amp; p );
};

template&lt;InputIterator Iter&gt; 
concept_map Range&lt; const pair&lt;Iter,Iter&gt; &gt; 
{ 
    typedef Iter iterator; 
    Iter begin( const pair&lt;Iter,Iter&gt;&amp; p );
    Iter end( const pair&lt;Iter,Iter&gt;&amp; p );
};
</pre>
<ul class="simple">
<li><tt class="docutils literal"><span class="pre">Iter</span> <span class="pre">begin(</span> <span class="pre">pair&lt;Iter,Iter&gt;&amp;</span> <span class="pre">p</span> <span class="pre">);</span></tt></li>
<li><tt class="docutils literal"><span class="pre">Iter</span> <span class="pre">begin(</span> <span class="pre">const</span> <span class="pre">pair&lt;Iter,Iter&gt;&amp;</span> <span class="pre">p</span> <span class="pre">);</span></tt></li>
</ul>
<p>2 <em>Returns</em>: <tt class="docutils literal"><span class="pre">p.first</span></tt></p>
<ul class="simple">
<li><tt class="docutils literal"><span class="pre">Iter</span> <span class="pre">end(</span> <span class="pre">pair&lt;Iter,Iter&gt;&amp;</span> <span class="pre">p</span> <span class="pre">);</span></tt></li>
<li><tt class="docutils literal"><span class="pre">Iter</span> <span class="pre">end(</span> <span class="pre">const</span> <span class="pre">pair&lt;Iter,Iter&gt;&amp;</span> <span class="pre">p</span> <span class="pre">);</span></tt></li>
</ul>
<p>3 <em>Returns</em>: <tt class="docutils literal"><span class="pre">p.second</span></tt></p>
</div>
<div class="section">
<h2><a class="toc-backref" href="#id18" id="header-tuple-synopsis" name="header-tuple-synopsis">20.3 Header <tt class="docutils literal docutils literal"><span class="pre">&lt;tuple&gt;</span></tt> synopsis</a></h2>
<p><strong>Add the following to the synopsis</strong>:</p>
<pre class="literal-block">
template&lt;InputIterator Iter&gt; 
concept_map Range&lt; tuple&lt;Iter,Iter&gt; &gt; 
{ <em>see below</em> }

template&lt;InputIterator Iter&gt; 
concept_map Range&lt; const tuple&lt;Iter,Iter&gt; &gt; 
{ <em>see below</em> }
</pre>
</div>
<div class="section">
<h2><a class="toc-backref" href="#id19" id="tuple-concept-maps" name="tuple-concept-maps">20.3.1.6 tuple concept maps</a></h2>
<p><strong>Add the following new section</strong>:</p>
<p>1 A <tt class="docutils literal"><span class="pre">tuple</span></tt> object of two iterators can be used with the range-based <tt class="docutils literal"><span class="pre">for</span></tt> statement due to
the following concept maps:</p>
<pre class="literal-block">
template&lt;InputIterator Iter&gt; 
concept_map Range&lt; tuple&lt;Iter,Iter&gt; &gt; 
{ 
    typedef Iter iterator; 
    Iter begin( tuple&lt;Iter,Iter&gt;&amp; p );
    Iter end( tuple&lt;Iter,Iter&gt;&amp; p );
};

template&lt;InputIterator Iter&gt; 
concept_map Range&lt; const tuple&lt;Iter,Iter&gt; &gt; 
{ 
    typedef Iter iterator; 
    Iter begin( const tuple&lt;Iter,Iter&gt;&amp; p );
    Iter end( const tuple&lt;Iter,Iter&gt;&amp; p );
};
</pre>
<ul class="simple">
<li><tt class="docutils literal"><span class="pre">Iter</span> <span class="pre">begin(</span> <span class="pre">tuple&lt;Iter,Iter&gt;&amp;</span> <span class="pre">p</span> <span class="pre">);</span></tt></li>
<li><tt class="docutils literal"><span class="pre">Iter</span> <span class="pre">begin(</span> <span class="pre">const</span> <span class="pre">tuple&lt;Iter,Iter&gt;&amp;</span> <span class="pre">p</span> <span class="pre">);</span></tt></li>
</ul>
<p>2 <em>Returns</em>: <tt class="docutils literal"><span class="pre">std::get&lt;0&gt;(p)</span></tt></p>
<ul class="simple">
<li><tt class="docutils literal"><span class="pre">Iter</span> <span class="pre">end(</span> <span class="pre">tuple&lt;Iter,Iter&gt;&amp;</span> <span class="pre">p</span> <span class="pre">);</span></tt></li>
<li><tt class="docutils literal"><span class="pre">Iter</span> <span class="pre">end(</span> <span class="pre">const</span> <span class="pre">tuple&lt;Iter,Iter&gt;&amp;</span> <span class="pre">p</span> <span class="pre">);</span></tt></li>
</ul>
<p>3 <em>Returns</em>: <tt class="docutils literal"><span class="pre">std::get&lt;1&gt;(p)</span></tt></p>
</div>
<div class="section">
<h2><a class="toc-backref" href="#id20" id="header-valarray-synopsis" name="header-valarray-synopsis">26.5.1 Header <tt class="docutils literal docutils literal"><span class="pre">&lt;valarray&gt;</span></tt> synopsis</a></h2>
<p><strong>Add the following to the synopsis</strong>:</p>
<pre class="literal-block">
template&lt;class T&gt;
concept_map Range&lt; valarray&lt;T&gt; &gt;
{ <em>see below</em>/ }

template&lt;class T&gt;
concept_map Range&lt; const valarray&lt;T&gt; &gt;
{ <em>see below</em> }
</pre>
</div>
<div class="section">
<h2><a class="toc-backref" href="#id21" id="valarray-concept-maps" name="valarray-concept-maps">26.5.2.7 valarray concept maps</a></h2>
<p><strong>Add the following new section</strong>:</p>
<p>1 <tt class="docutils literal"><span class="pre">valarray</span></tt> objects can be used with the range-based <tt class="docutils literal"><span class="pre">for</span></tt> statement due to
the following concept maps.</p>
<pre class="literal-block">
template&lt;class T&gt;
concept_map Range&lt; valarray&lt;T&gt; &gt;
{
    typedef <em>unspecified type</em> iterator;
    iterator begin( valarray&lt;T&gt;&amp; a );
    iterator end( valarray&lt;T&gt;&amp; a );
};
</pre>
<ul class="simple">
<li><tt class="docutils literal"><span class="pre">typedef</span></tt> <em>unspecified type</em> <tt class="docutils literal"><span class="pre">iterator;</span></tt></li>
</ul>
<p>2 <em>Requires</em>: <tt class="docutils literal"><span class="pre">iterator</span></tt> shall meet the requirements of the <tt class="docutils literal"><span class="pre">MutableRandomAccessIterator</span></tt> concept</p>
<ul class="simple">
<li><tt class="docutils literal"><span class="pre">iterator</span> <span class="pre">begin(</span> <span class="pre">valarray&lt;T&gt;&amp;</span> <span class="pre">a</span> <span class="pre">);</span></tt></li>
</ul>
<p>3 <em>Returns</em>: an iterator referencing the first value in the numeric array.</p>
<ul class="simple">
<li><tt class="docutils literal"><span class="pre">iterator</span> <span class="pre">end(</span> <span class="pre">valarray&lt;T&gt;&amp;</span> <span class="pre">a</span> <span class="pre">);</span></tt></li>
</ul>
<p>4 <em>Returns</em>: an iterator one past the last value in the numeric array.</p>
<pre class="literal-block">
template&lt;class T&gt;
concept_map Range&lt; const valarray&lt;T&gt; &gt;
{ 
    typedef <em>unspecified type</em> iterator; 
    iterator begin( const valarray&lt;T&gt;&amp; a );
    iterator end( const valarray&lt;T&gt;&amp; a );
};
</pre>
<ul class="simple">
<li><tt class="docutils literal"><span class="pre">typedef</span></tt> <em>unspecified type</em> <tt class="docutils literal"><span class="pre">iterator;</span></tt></li>
</ul>
<p>5 <em>Requires</em>: <tt class="docutils literal"><span class="pre">iterator</span></tt> shall meet the requirements of the <tt class="docutils literal"><span class="pre">RandomAccessIterator</span></tt> concept but not
<tt class="docutils literal"><span class="pre">MutableRandomAccessIterator</span></tt>.</p>
<ul class="simple">
<li><tt class="docutils literal"><span class="pre">iterator</span> <span class="pre">begin(</span> <span class="pre">const</span> <span class="pre">valarray&lt;T&gt;&amp;</span> <span class="pre">a</span> <span class="pre">);</span></tt></li>
</ul>
<p>6 <em>Returns</em>: an iterator referencing the first value in the numeric array.</p>
<ul class="simple">
<li><tt class="docutils literal"><span class="pre">iterator</span> <span class="pre">end(</span> <span class="pre">const</span> <span class="pre">valarray&lt;T&gt;&amp;</span> <span class="pre">a</span> <span class="pre">);</span></tt></li>
</ul>
<p>7 <em>Returns</em>: an iterator one past the last value in the numeric array.</p>
</div>
<div class="section">
<h2><a class="toc-backref" href="#id22" id="header-regex-synopsis" name="header-regex-synopsis">28.4 Header <tt class="docutils literal docutils literal"><span class="pre">&lt;regex&gt;</span></tt> synopsis</a></h2>
<p><strong>Add the following to the synopsis</strong>:</p>
<pre class="literal-block">
&lt;BidirectionalIterator Iter&gt; 
concept_map Range&lt; sub_match&lt;Iter&gt; &gt; 
{ <em>see below</em> }

template&lt;BidirectionalIterator Iter&gt; 
concept_map Range&lt; const sub_match&lt;Iter&gt; &gt;
{ <em>see below</em> }
</pre>
</div>
<div class="section">
<h2><a class="toc-backref" href="#id23" id="sub-match-concept-maps" name="sub-match-concept-maps">28.9.3 sub_match concept maps</a></h2>
<p><strong>Add the following new section</strong>:</p>
<p>1 <tt class="docutils literal"><span class="pre">sub_match</span></tt> objects can be used with the range-based <tt class="docutils literal"><span class="pre">for</span></tt> statement due to
the following concept maps:</p>
<pre class="literal-block">
&lt;BidirectionalIterator Iter&gt; 
concept_map Range&lt; sub_match&lt;Iter&gt; &gt; 
{ 
    typedef Iter iterator; 
    Iter begin( sub_match&lt;Iter&gt;&amp; p );
    Iter end( sub_match&lt;Iter&gt;&amp; p );
};

template&lt;BidirectionalIterator Iter&gt; 
concept_map Range&lt; const sub_match&lt;Iter&gt; &gt; 
{ 
    typedef Iter iterator; 
    Iter begin( const sub_match&lt;Iter&gt;&amp; p );
    Iter end( const sub_match&lt;Iter&gt;&amp; p );
};
</pre>
<ul class="simple">
<li><tt class="docutils literal"><span class="pre">Iter</span> <span class="pre">begin(</span> <span class="pre">sub_match&lt;Iter&gt;&amp;</span> <span class="pre">p</span> <span class="pre">);</span></tt></li>
<li><tt class="docutils literal"><span class="pre">Iter</span> <span class="pre">begin(</span> <span class="pre">const</span> <span class="pre">sub_match&lt;Iter&gt;&amp;</span> <span class="pre">p</span> <span class="pre">);</span></tt></li>
</ul>
<p>2 <em>Returns</em>: <tt class="docutils literal"><span class="pre">p.first</span></tt></p>
<ul class="simple">
<li><tt class="docutils literal"><span class="pre">Iter</span> <span class="pre">end(</span> <span class="pre">sub_match&lt;Iter&gt;&amp;</span> <span class="pre">p</span> <span class="pre">);</span></tt></li>
<li><tt class="docutils literal"><span class="pre">Iter</span> <span class="pre">end(</span> <span class="pre">const</span> <span class="pre">sub_match&lt;Iter&gt;&amp;</span> <span class="pre">p</span> <span class="pre">);</span></tt></li>
</ul>
<p>3 <em>Returns</em>: <tt class="docutils literal"><span class="pre">p.second</span></tt></p>
<!-- A Grammar summary -->
<!-- +++++++++++++++++ -->
<!-- **Add the following to section A.7 after the rule for 'declarator'** -->
<!--  -->
<!-- *simple-declarator:* -->
<!-- *declarator-id* -->
<!-- *ptr-operator* *simple-declarator* -->
<!-- ############################################### -->
<!-- ################## Links ###################### -->
<!-- ############################################### -->
<!-- ========= -->
<!-- Footnotes -->
<!-- ========= -->
<!-- ############################################### -->
<!-- ################## Footnotes ################## -->
<!-- ############################################### -->
</div>
</div>
</div>
</body>
</html>
